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 ==================================================================================
26 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
27 "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststube2ap"
28 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
29 "github.com/stretchr/testify/assert"
32 //-----------------------------------------------------------------------------
33 // TestSubReqAndRouteNok
36 // +-------+ +---------+ +---------+
37 // | xapp | | submgr | | rtmgr |
38 // +-------+ +---------+ +---------+
50 // | [SUBS INT DELETE] |
53 //-----------------------------------------------------------------------------
55 func TestSubReqAndRouteNok(t *testing.T) {
56 CaseBegin("TestSubReqAndRouteNok")
59 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
60 Counter{cSubReqFromXapp, 1},
61 Counter{cRouteCreateFail, 1},
64 waiter := rtmgrHttp.AllocNextEvent(false)
65 newSubsId := mainCtrl.get_registry_next_subid(t)
66 xappConn1.SendSubsReq(t, nil, nil)
69 //Wait that subs is cleaned
70 mainCtrl.wait_subs_clean(t, newSubsId, 10)
72 xappConn1.TestMsgChanEmpty(t)
73 xappConn2.TestMsgChanEmpty(t)
74 e2termConn1.TestMsgChanEmpty(t)
75 mainCtrl.wait_registry_empty(t, 10)
77 <-time.After(1 * time.Second)
78 mainCtrl.VerifyCounterValues(t)
81 //-----------------------------------------------------------------------------
82 // TestSubReqAndRouteUpdateNok
85 // +-------+ +-------+ +---------+ +---------+
86 // | xapp2 | | xapp1 | | submgr | | rtmgr |
87 // +-------+ +-------+ +---------+ +---------+
89 // | [SUBS CREATE] | |
93 // | SubReq (mergeable) | |
94 // |--------------------------->| | |
96 // | | | RouteUpdate |
97 // | | |------------->|
99 // | | | RouteUpdate |
100 // | | | status:400 |
101 // | | |<-------------|
103 // | [SUBS INT DELETE] | |
106 // | [SUBS DELETE] | |
108 func TestSubReqAndRouteUpdateNok(t *testing.T) {
109 CaseBegin("TestSubReqAndRouteUpdateNok")
111 // Init counter check
112 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
113 Counter{cSubReqFromXapp, 2},
114 Counter{cSubReqToE2, 1},
115 Counter{cSubRespFromE2, 1},
116 Counter{cSubRespToXapp, 1},
117 Counter{cRouteCreateUpdateFail, 1},
118 Counter{cSubDelReqFromXapp, 1},
119 Counter{cSubDelReqToE2, 1},
120 Counter{cSubDelRespFromE2, 1},
121 Counter{cSubDelRespToXapp, 1},
124 cretrans := xappConn1.SendSubsReq(t, nil, nil)
125 crereq, cremsg := e2termConn1.RecvSubsReq(t)
126 e2termConn1.SendSubsResp(t, crereq, cremsg)
127 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
129 resp, _ := xapp.Subscription.QuerySubscriptions()
130 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
131 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
132 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560"})
134 waiter := rtmgrHttp.AllocNextEvent(false)
135 newSubsId := mainCtrl.get_registry_next_subid(t)
136 xappConn2.SendSubsReq(t, nil, nil)
139 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
140 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
142 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
143 xappConn1.RecvSubsDelResp(t, deltrans)
145 //Wait that subs is cleaned
146 mainCtrl.wait_subs_clean(t, newSubsId, 10)
147 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
149 xappConn1.TestMsgChanEmpty(t)
150 xappConn2.TestMsgChanEmpty(t)
151 e2termConn1.TestMsgChanEmpty(t)
152 mainCtrl.wait_registry_empty(t, 10)
154 mainCtrl.VerifyCounterValues(t)
157 //-----------------------------------------------------------------------------
158 // TestSubDelReqAndRouteDeleteNok
161 // +-------+ +---------+ +---------+ +---------+
162 // | xapp | | submgr | | e2term | | rtmgr |
163 // +-------+ +---------+ +---------+ +---------+
165 // | [SUBS CREATE] | |
170 // |------------->| | |
172 // | |------------->| |
174 // | |<-------------| |
176 // |<-------------| | |
177 // | | RouteDelete | |
178 // | |---------------------------->|
180 // | | RouteDelete | |
181 // | | status:400 | |
182 // | |<----------------------------|
184 func TestSubDelReqAndRouteDeleteNok(t *testing.T) {
185 CaseBegin("TestSubDelReqAndRouteDeleteNok")
187 // Init counter check
188 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
189 Counter{cSubReqFromXapp, 1},
190 Counter{cSubReqToE2, 1},
191 Counter{cSubRespFromE2, 1},
192 Counter{cSubRespToXapp, 1},
193 Counter{cSubDelReqFromXapp, 1},
194 Counter{cRouteDeleteFail, 1},
195 Counter{cSubDelReqToE2, 1},
196 Counter{cSubDelRespFromE2, 1},
197 Counter{cSubDelRespToXapp, 1},
200 cretrans := xappConn1.SendSubsReq(t, nil, nil)
201 crereq, cremsg := e2termConn1.RecvSubsReq(t)
202 e2termConn1.SendSubsResp(t, crereq, cremsg)
203 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
205 resp, _ := xapp.Subscription.QuerySubscriptions()
206 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
207 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
208 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560"})
210 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
211 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
213 waiter := rtmgrHttp.AllocNextEvent(false)
214 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
217 xappConn1.RecvSubsDelResp(t, deltrans)
219 //Wait that subs is cleaned
220 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
222 xappConn1.TestMsgChanEmpty(t)
223 xappConn2.TestMsgChanEmpty(t)
224 e2termConn1.TestMsgChanEmpty(t)
225 mainCtrl.wait_registry_empty(t, 10)
227 mainCtrl.VerifyCounterValues(t)
230 //-----------------------------------------------------------------------------
231 // TestSubMergeDelAndRouteUpdateNok
233 // +-------+ +-------+ +---------+ +---------+
234 // | xapp2 | | xapp1 | | submgr | | e2term |
235 // +-------+ +-------+ +---------+ +---------+
240 // | |------------->| |
243 // | | |------------->|
245 // | | |<-------------|
247 // | |<-------------| |
250 // |--------------------------->| |
253 // |<---------------------------| |
255 // | | SubDelReq 1 | |
256 // | |------------->| |
257 // | | | RouteUpdate |
258 // | | |-----> rtmgr |
260 // | | | RouteUpdate |
261 // | | | status:400 |
262 // | | |<----- rtmgr |
264 // | | SubDelResp 1 | |
265 // | |<-------------| |
268 // |--------------------------->| |
270 // | | | SubDelReq 2 |
271 // | | |------------->|
273 // | | | SubDelReq 2 |
274 // | | |------------->|
276 // | SubDelResp 2 | |
277 // |<---------------------------| |
279 //-----------------------------------------------------------------------------
280 func TestSubMergeDelAndRouteUpdateNok(t *testing.T) {
281 CaseBegin("TestSubMergeDelAndRouteUpdateNok")
283 // Init counter check
284 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
285 Counter{cSubReqFromXapp, 2},
286 Counter{cSubReqToE2, 1},
287 Counter{cSubRespFromE2, 1},
288 Counter{cSubRespToXapp, 2},
289 Counter{cSubDelReqFromXapp, 2},
290 Counter{cRouteDeleteUpdateFail, 1},
291 Counter{cSubDelReqToE2, 1},
292 Counter{cSubDelRespFromE2, 1},
293 Counter{cSubDelRespToXapp, 2},
297 rparams1 := &teststube2ap.E2StubSubsReqParams{}
299 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
300 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
301 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
302 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
305 rparams2 := &teststube2ap.E2StubSubsReqParams{}
307 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
308 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
310 resp, _ := xapp.Subscription.QuerySubscriptions()
311 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
312 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
313 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560", "localhost:13660"})
316 waiter := rtmgrHttp.AllocNextEvent(false)
317 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
320 xappConn1.RecvSubsDelResp(t, deltrans1)
323 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
324 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
325 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
326 xappConn2.RecvSubsDelResp(t, deltrans2)
327 //Wait that subs is cleaned
328 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
330 xappConn1.TestMsgChanEmpty(t)
331 xappConn2.TestMsgChanEmpty(t)
332 e2termConn1.TestMsgChanEmpty(t)
333 mainCtrl.wait_registry_empty(t, 10)
335 mainCtrl.VerifyCounterValues(t)
338 //-----------------------------------------------------------------------------
340 //-----------------------------------------------------------------------------
341 // TestSubReqAndSubDelOk
344 // +-------+ +---------+ +---------+
345 // | xapp | | submgr | | e2term |
346 // +-------+ +---------+ +---------+
349 // |------------->| |
352 // | |------------->|
355 // | |<-------------|
358 // |<-------------| |
362 // |------------->| |
365 // | |------------->|
368 // | |<-------------|
371 // |<-------------| |
373 //-----------------------------------------------------------------------------
374 func TestSubReqAndSubDelOk(t *testing.T) {
375 CaseBegin("TestSubReqAndSubDelOk")
377 // Init counter check
378 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
379 Counter{cSubReqFromXapp, 1},
380 Counter{cSubReqToE2, 1},
381 Counter{cSubRespFromE2, 1},
382 Counter{cSubRespToXapp, 1},
383 Counter{cSubDelReqFromXapp, 1},
384 Counter{cSubDelReqToE2, 1},
385 Counter{cSubDelRespFromE2, 1},
386 Counter{cSubDelRespToXapp, 1},
389 cretrans := xappConn1.SendSubsReq(t, nil, nil)
390 crereq, cremsg := e2termConn1.RecvSubsReq(t)
391 e2termConn1.SendSubsResp(t, crereq, cremsg)
392 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
394 resp, _ := xapp.Subscription.QuerySubscriptions()
395 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
396 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
397 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560"})
399 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
400 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
402 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
403 xappConn1.RecvSubsDelResp(t, deltrans)
405 //Wait that subs is cleaned
406 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
408 xappConn1.TestMsgChanEmpty(t)
409 xappConn2.TestMsgChanEmpty(t)
410 e2termConn1.TestMsgChanEmpty(t)
411 mainCtrl.wait_registry_empty(t, 10)
413 mainCtrl.VerifyCounterValues(t)
416 //-----------------------------------------------------------------------------
417 // TestSubReqRetransmission
420 // +-------+ +---------+ +---------+
421 // | xapp | | submgr | | e2term |
422 // +-------+ +---------+ +---------+
425 // |------------->| |
428 // | |------------->|
432 // |------------->| |
435 // | |<-------------|
438 // |<-------------| |
443 //-----------------------------------------------------------------------------
444 func TestSubReqRetransmission(t *testing.T) {
445 CaseBegin("TestSubReqRetransmission")
448 cretrans := xappConn1.SendSubsReq(t, nil, nil)
449 crereq, cremsg := e2termConn1.RecvSubsReq(t)
451 seqBef := mainCtrl.get_msgcounter(t)
452 xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq
453 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
455 // hack as there is no real way to see has message be handled.
456 // Previuos counter check just tells that is has been received by submgr
457 // --> artificial delay
458 <-time.After(1 * time.Second)
459 e2termConn1.SendSubsResp(t, crereq, cremsg)
460 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
463 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
464 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
465 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
466 xappConn1.RecvSubsDelResp(t, deltrans)
468 //Wait that subs is cleaned
469 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
471 xappConn1.TestMsgChanEmpty(t)
472 xappConn2.TestMsgChanEmpty(t)
473 e2termConn1.TestMsgChanEmpty(t)
474 mainCtrl.wait_registry_empty(t, 10)
477 //-----------------------------------------------------------------------------
478 // TestSubDelReqRetransmission
481 // +-------+ +---------+ +---------+
482 // | xapp | | submgr | | e2term |
483 // +-------+ +---------+ +---------+
489 // |------------->| |
492 // | |------------->|
497 // |------------->| |
500 // | |<-------------|
503 // |<-------------| |
505 //-----------------------------------------------------------------------------
506 func TestSubDelReqRetransmission(t *testing.T) {
507 CaseBegin("TestSubDelReqRetransmission")
510 cretrans := xappConn1.SendSubsReq(t, nil, nil)
511 crereq, cremsg := e2termConn1.RecvSubsReq(t)
512 e2termConn1.SendSubsResp(t, crereq, cremsg)
513 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
516 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
517 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
519 seqBef := mainCtrl.get_msgcounter(t)
520 xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq
521 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
523 // hack as there is no real way to see has message be handled.
524 // Previuos counter check just tells that is has been received by submgr
525 // --> artificial delay
526 <-time.After(1 * time.Second)
528 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
529 xappConn1.RecvSubsDelResp(t, deltrans)
531 //Wait that subs is cleaned
532 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
534 xappConn1.TestMsgChanEmpty(t)
535 xappConn2.TestMsgChanEmpty(t)
536 e2termConn1.TestMsgChanEmpty(t)
537 mainCtrl.wait_registry_empty(t, 10)
540 //-----------------------------------------------------------------------------
541 // TestSubDelReqCollision
544 // +-------+ +---------+ +---------+
545 // | xapp | | submgr | | e2term |
546 // +-------+ +---------+ +---------+
552 // |------------->| |
555 // | |------------->|
560 // |------------->| |
562 // | | SubDelResp 1 |
563 // | |<-------------|
565 // | SubDelResp 1 | |
566 // |<-------------| |
568 // | SubDelResp 2 | |
569 // |<-------------| |
571 //-----------------------------------------------------------------------------
573 func TestSubDelReqCollision(t *testing.T) {
574 CaseBegin("TestSubDelReqCollision")
577 cretrans := xappConn1.SendSubsReq(t, nil, nil)
578 crereq, cremsg := e2termConn1.RecvSubsReq(t)
579 e2termConn1.SendSubsResp(t, crereq, cremsg)
580 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
583 xappConn1.SendSubsDelReq(t, nil, e2SubsId)
584 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
586 // Subs Delete colliding
587 seqBef := mainCtrl.get_msgcounter(t)
588 deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
589 xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq
590 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
592 // hack as there is no real way to see has message be handled.
593 // Previuos counter check just tells that is has been received by submgr
594 // --> artificial delay
595 <-time.After(1 * time.Second)
597 // Del resp for first and second
598 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
600 // don't care in which order responses are received
601 xappConn1.RecvSubsDelResp(t, nil)
602 xappConn1.RecvSubsDelResp(t, nil)
604 //Wait that subs is cleaned
605 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
607 xappConn1.TestMsgChanEmpty(t)
608 xappConn2.TestMsgChanEmpty(t)
609 e2termConn1.TestMsgChanEmpty(t)
610 mainCtrl.wait_registry_empty(t, 10)
613 //-----------------------------------------------------------------------------
614 // TestSubReqAndSubDelOkTwoParallel
617 // +-------+ +-------+ +---------+ +---------+
618 // | xapp | | xapp | | submgr | | e2term |
619 // +-------+ +-------+ +---------+ +---------+
624 // | |------------->| |
627 // | | |------------->|
630 // |------------------------>| |
633 // | | |------------->|
636 // | | |<-------------|
638 // | |<-------------| |
641 // | | |<-------------|
643 // |<------------------------| |
645 // | | [SUBS 1 DELETE] |
647 // | | [SUBS 2 DELETE] |
650 //-----------------------------------------------------------------------------
651 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
652 CaseBegin("TestSubReqAndSubDelOkTwoParallel")
655 rparams1 := &teststube2ap.E2StubSubsReqParams{}
657 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
658 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
661 rparams2 := &teststube2ap.E2StubSubsReqParams{}
664 rparams2.Req.EventTriggerDefinition.Data.Length = 1
665 rparams2.Req.EventTriggerDefinition.Data.Data = make([]uint8, rparams2.Req.EventTriggerDefinition.Data.Length)
666 rparams2.Req.EventTriggerDefinition.Data.Data[0] = 2
668 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
669 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
672 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
673 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
676 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
677 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
680 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
681 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
682 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
683 xappConn1.RecvSubsDelResp(t, deltrans1)
684 //Wait that subs is cleaned
685 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
688 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
689 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
690 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
691 xappConn2.RecvSubsDelResp(t, deltrans2)
692 //Wait that subs is cleaned
693 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
695 xappConn1.TestMsgChanEmpty(t)
696 xappConn2.TestMsgChanEmpty(t)
697 e2termConn1.TestMsgChanEmpty(t)
698 mainCtrl.wait_registry_empty(t, 10)
701 //-----------------------------------------------------------------------------
702 // TestSameSubsDiffRan
703 // Same subscription to different RANs
706 // +-------+ +---------+ +---------+
707 // | xapp | | submgr | | e2term |
708 // +-------+ +---------+ +---------+
713 // |------------->| |
716 // | |------------->|
719 // | |<-------------|
722 // |<-------------| |
725 // |------------->| |
728 // | |------------->|
731 // | |<-------------|
734 // |<-------------| |
736 // | [SUBS r1 DELETE] |
738 // | [SUBS r2 DELETE] |
741 //-----------------------------------------------------------------------------
742 func TestSameSubsDiffRan(t *testing.T) {
743 CaseBegin("TestSameSubsDiffRan")
746 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
747 xappConn1.SendSubsReq(t, nil, cretrans1)
748 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
749 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
750 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
753 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
754 xappConn1.SendSubsReq(t, nil, cretrans2)
755 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
756 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
757 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
760 deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
761 xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
762 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
763 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
764 xappConn1.RecvSubsDelResp(t, deltrans1)
765 //Wait that subs is cleaned
766 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
769 deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
770 xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
771 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
772 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
773 xappConn1.RecvSubsDelResp(t, deltrans2)
774 //Wait that subs is cleaned
775 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
777 xappConn1.TestMsgChanEmpty(t)
778 xappConn2.TestMsgChanEmpty(t)
779 e2termConn1.TestMsgChanEmpty(t)
780 mainCtrl.wait_registry_empty(t, 10)
783 //-----------------------------------------------------------------------------
784 // TestSubReqRetryInSubmgr
787 // +-------+ +---------+ +---------+
788 // | xapp | | submgr | | e2term |
789 // +-------+ +---------+ +---------+
792 // |------------->| |
795 // | |------------->|
799 // | |------------->|
802 // | |<-------------|
805 // |<-------------| |
810 //-----------------------------------------------------------------------------
812 func TestSubReqRetryInSubmgr(t *testing.T) {
813 CaseBegin("TestSubReqRetryInSubmgr start")
815 // Init counter check
816 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
817 Counter{cSubReqFromXapp, 1},
818 Counter{cSubReqToE2, 1},
819 Counter{cSubReReqToE2, 1},
820 Counter{cSubRespFromE2, 1},
821 Counter{cSubRespToXapp, 1},
822 Counter{cSubDelReqFromXapp, 1},
823 Counter{cSubDelReqToE2, 1},
824 Counter{cSubDelRespFromE2, 1},
825 Counter{cSubDelRespToXapp, 1},
828 // Xapp: Send SubsReq
829 cretrans := xappConn1.SendSubsReq(t, nil, nil)
831 // E2t: Receive 1st SubsReq
832 e2termConn1.RecvSubsReq(t)
834 // E2t: Receive 2nd SubsReq and send SubsResp
835 crereq, cremsg := e2termConn1.RecvSubsReq(t)
836 e2termConn1.SendSubsResp(t, crereq, cremsg)
838 // Xapp: Receive SubsResp
839 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
841 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
842 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
843 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
844 xappConn1.RecvSubsDelResp(t, deltrans)
846 // Wait that subs is cleaned
847 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
849 xappConn1.TestMsgChanEmpty(t)
850 xappConn2.TestMsgChanEmpty(t)
851 e2termConn1.TestMsgChanEmpty(t)
852 mainCtrl.wait_registry_empty(t, 10)
854 mainCtrl.VerifyCounterValues(t)
857 //-----------------------------------------------------------------------------
858 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
861 // +-------+ +---------+ +---------+
862 // | xapp | | submgr | | e2term |
863 // +-------+ +---------+ +---------+
866 // |------------->| |
869 // | |------------->|
873 // | |------------->|
876 // | |------------->|
879 // | |<-------------|
882 //-----------------------------------------------------------------------------
884 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
885 CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
887 // Init counter check
888 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
889 Counter{cSubReqFromXapp, 1},
890 Counter{cSubReqToE2, 1},
891 Counter{cSubReReqToE2, 1},
892 Counter{cSubReqTimerExpiry, 2},
893 Counter{cSubDelReqToE2, 1},
894 Counter{cSubDelRespFromE2, 1},
897 // Xapp: Send SubsReq
898 xappConn1.SendSubsReq(t, nil, nil)
900 // E2t: Receive 1st SubsReq
901 e2termConn1.RecvSubsReq(t)
903 // E2t: Receive 2nd SubsReq
904 e2termConn1.RecvSubsReq(t)
906 // E2t: Send receive SubsDelReq and send SubsResp
907 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
908 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
910 // Wait that subs is cleaned
911 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 10)
913 xappConn1.TestMsgChanEmpty(t)
914 xappConn2.TestMsgChanEmpty(t)
915 e2termConn1.TestMsgChanEmpty(t)
916 mainCtrl.wait_registry_empty(t, 10)
918 mainCtrl.VerifyCounterValues(t)
921 //-----------------------------------------------------------------------------
922 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
925 // +-------+ +---------+ +---------+
926 // | xapp | | submgr | | e2term |
927 // +-------+ +---------+ +---------+
930 // |------------->| |
933 // | |------------->|
937 // | |------------->|
940 // | |------------->|
944 // | |------------->|
948 //-----------------------------------------------------------------------------
950 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
951 CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
953 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
954 Counter{cSubReqFromXapp, 1},
955 Counter{cSubReqToE2, 1},
956 Counter{cSubReReqToE2, 1},
957 Counter{cSubReqTimerExpiry, 2},
958 Counter{cSubDelReqToE2, 1},
959 Counter{cSubDelReReqToE2, 1},
960 Counter{cSubDelReqTimerExpiry, 2},
963 // Xapp: Send SubsReq
964 xappConn1.SendSubsReq(t, nil, nil)
966 // E2t: Receive 1st SubsReq
967 e2termConn1.RecvSubsReq(t)
969 // E2t: Receive 2nd SubsReq
970 e2termConn1.RecvSubsReq(t)
972 // E2t: Receive 1st SubsDelReq
973 e2termConn1.RecvSubsDelReq(t)
975 // E2t: Receive 2nd SubsDelReq
976 delreq, _ := e2termConn1.RecvSubsDelReq(t)
978 // Wait that subs is cleaned
979 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 15)
981 xappConn1.TestMsgChanEmpty(t)
982 xappConn2.TestMsgChanEmpty(t)
983 e2termConn1.TestMsgChanEmpty(t)
984 mainCtrl.wait_registry_empty(t, 10)
986 mainCtrl.VerifyCounterValues(t)
989 //-----------------------------------------------------------------------------
990 // TestSubReqSubFailRespInSubmgr
993 // +-------+ +---------+ +---------+
994 // | xapp | | submgr | | e2term |
995 // +-------+ +---------+ +---------+
998 // |------------->| |
1001 // | |------------->|
1004 // | |<-------------|
1007 // |<-------------| |
1010 //-----------------------------------------------------------------------------
1012 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1013 CaseBegin("TestSubReqSubFailRespInSubmgr start")
1015 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1016 Counter{cSubReqFromXapp, 1},
1017 Counter{cSubReqToE2, 1},
1018 Counter{cSubFailFromE2, 1},
1019 Counter{cSubFailToXapp, 1},
1022 // Xapp: Send SubsReq
1023 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1025 // E2t: Receive SubsReq and send SubsFail (first)
1026 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1027 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1028 fparams1.Set(crereq1)
1029 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1031 // Xapp: Receive SubsFail
1032 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
1034 // Wait that subs is cleaned
1035 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1037 xappConn1.TestMsgChanEmpty(t)
1038 xappConn2.TestMsgChanEmpty(t)
1039 e2termConn1.TestMsgChanEmpty(t)
1040 mainCtrl.wait_registry_empty(t, 10)
1042 mainCtrl.VerifyCounterValues(t)
1045 //-----------------------------------------------------------------------------
1046 // TestSubDelReqRetryInSubmgr
1049 // +-------+ +---------+ +---------+
1050 // | xapp | | submgr | | e2term |
1051 // +-------+ +---------+ +---------+
1053 // | [SUBS CREATE] |
1057 // |------------->| |
1060 // | |------------->|
1063 // | |------------->|
1066 // | |<-------------|
1069 // |<-------------| |
1071 //-----------------------------------------------------------------------------
1073 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1075 CaseBegin("TestSubDelReqRetryInSubmgr start")
1078 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1079 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1080 e2termConn1.SendSubsResp(t, crereq, cremsg)
1081 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1084 // Xapp: Send SubsDelReq
1085 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1087 // E2t: Receive 1st SubsDelReq
1088 e2termConn1.RecvSubsDelReq(t)
1090 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1091 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1092 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1094 // Xapp: Receive SubsDelResp
1095 xappConn1.RecvSubsDelResp(t, deltrans)
1097 // Wait that subs is cleaned
1098 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1100 xappConn1.TestMsgChanEmpty(t)
1101 xappConn2.TestMsgChanEmpty(t)
1102 e2termConn1.TestMsgChanEmpty(t)
1103 mainCtrl.wait_registry_empty(t, 10)
1106 //-----------------------------------------------------------------------------
1107 // TestSubDelReqTwoRetriesNoRespInSubmgr
1110 // +-------+ +---------+ +---------+
1111 // | xapp | | submgr | | e2term |
1112 // +-------+ +---------+ +---------+
1114 // | [SUBS CREATE] |
1118 // |------------->| |
1121 // | |------------->|
1124 // | |------------->|
1128 // |<-------------| |
1130 //-----------------------------------------------------------------------------
1132 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1134 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
1137 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1138 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1139 e2termConn1.SendSubsResp(t, crereq, cremsg)
1140 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1143 // Xapp: Send SubsDelReq
1144 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1146 // E2t: Receive 1st SubsDelReq
1147 e2termConn1.RecvSubsDelReq(t)
1149 // E2t: Receive 2nd SubsDelReq
1150 e2termConn1.RecvSubsDelReq(t)
1152 // Xapp: Receive SubsDelResp
1153 xappConn1.RecvSubsDelResp(t, deltrans)
1155 // Wait that subs is cleaned
1156 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1158 xappConn1.TestMsgChanEmpty(t)
1159 xappConn2.TestMsgChanEmpty(t)
1160 e2termConn1.TestMsgChanEmpty(t)
1161 mainCtrl.wait_registry_empty(t, 10)
1164 //-----------------------------------------------------------------------------
1165 // TestSubDelReqSubDelFailRespInSubmgr
1168 // +-------+ +---------+ +---------+
1169 // | xapp | | submgr | | e2term |
1170 // +-------+ +---------+ +---------+
1172 // | [SUBS CREATE] |
1176 // |------------->| |
1179 // | |------------->|
1182 // | |<-------------|
1185 // |<-------------| |
1188 //-----------------------------------------------------------------------------
1190 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1191 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1193 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1194 Counter{cSubReqFromXapp, 1},
1195 Counter{cSubReqToE2, 1},
1196 Counter{cSubRespFromE2, 1},
1197 Counter{cSubRespToXapp, 1},
1198 Counter{cSubDelReqFromXapp, 1},
1199 Counter{cSubDelReqToE2, 1},
1200 Counter{cSubDelFailFromE2, 1},
1201 Counter{cSubDelRespToXapp, 1},
1205 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1206 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1207 e2termConn1.SendSubsResp(t, crereq, cremsg)
1208 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1210 // Xapp: Send SubsDelReq
1211 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1213 // E2t: Send receive SubsDelReq and send SubsDelFail
1214 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1215 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1217 // Xapp: Receive SubsDelResp
1218 xappConn1.RecvSubsDelResp(t, deltrans)
1220 // Wait that subs is cleaned
1221 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1223 xappConn1.TestMsgChanEmpty(t)
1224 xappConn2.TestMsgChanEmpty(t)
1225 e2termConn1.TestMsgChanEmpty(t)
1226 mainCtrl.wait_registry_empty(t, 10)
1228 mainCtrl.VerifyCounterValues(t)
1231 //-----------------------------------------------------------------------------
1232 // TestSubReqAndSubDelOkSameAction
1235 // +-------+ +-------+ +---------+ +---------+
1236 // | xapp2 | | xapp1 | | submgr | | e2term |
1237 // +-------+ +-------+ +---------+ +---------+
1242 // | |------------->| |
1245 // | | |------------->|
1247 // | | |<-------------|
1249 // | |<-------------| |
1252 // |--------------------------->| |
1255 // |<---------------------------| |
1257 // | | SubDelReq 1 | |
1258 // | |------------->| |
1260 // | | SubDelResp 1 | |
1261 // | |<-------------| |
1263 // | SubDelReq 2 | |
1264 // |--------------------------->| |
1266 // | | | SubDelReq 2 |
1267 // | | |------------->|
1269 // | | | SubDelReq 2 |
1270 // | | |------------->|
1272 // | SubDelResp 2 | |
1273 // |<---------------------------| |
1275 //-----------------------------------------------------------------------------
1276 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
1277 CaseBegin("TestSubReqAndSubDelOkSameAction")
1279 // Init counter check
1280 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1281 Counter{cSubReqFromXapp, 2},
1282 Counter{cSubReqToE2, 1},
1283 Counter{cSubRespFromE2, 1},
1284 Counter{cSubRespToXapp, 2},
1285 Counter{cMergedSubscriptions, 1},
1286 Counter{cUnmergedSubscriptions, 1},
1287 Counter{cSubDelReqFromXapp, 2},
1288 Counter{cSubDelReqToE2, 1},
1289 Counter{cSubDelRespFromE2, 1},
1290 Counter{cSubDelRespToXapp, 2},
1294 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1296 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1297 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1298 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1299 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1302 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1304 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1305 //crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1306 //e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1307 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1309 resp, _ := xapp.Subscription.QuerySubscriptions()
1310 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1311 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1312 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560", "localhost:13660"})
1315 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1316 //e2termConn1.RecvSubsDelReq(t)
1317 //e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1318 xappConn1.RecvSubsDelResp(t, deltrans1)
1319 //Wait that subs is cleaned
1320 //mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1323 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1324 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1325 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1326 xappConn2.RecvSubsDelResp(t, deltrans2)
1327 //Wait that subs is cleaned
1328 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1330 xappConn1.TestMsgChanEmpty(t)
1331 xappConn2.TestMsgChanEmpty(t)
1332 e2termConn1.TestMsgChanEmpty(t)
1333 mainCtrl.wait_registry_empty(t, 10)
1335 mainCtrl.VerifyCounterValues(t)
1338 //-----------------------------------------------------------------------------
1339 // TestSubReqAndSubDelOkSameActionParallel
1342 // +-------+ +-------+ +---------+ +---------+
1343 // | xapp2 | | xapp1 | | submgr | | e2term |
1344 // +-------+ +-------+ +---------+ +---------+
1349 // | |------------->| |
1352 // | | |------------->|
1354 // |--------------------------->| |
1356 // | | |<-------------|
1358 // | |<-------------| |
1361 // |<---------------------------| |
1363 // | | SubDelReq 1 | |
1364 // | |------------->| |
1366 // | | SubDelResp 1 | |
1367 // | |<-------------| |
1369 // | SubDelReq 2 | |
1370 // |--------------------------->| |
1372 // | | | SubDelReq 2 |
1373 // | | |------------->|
1375 // | | | SubDelReq 2 |
1376 // | | |------------->|
1378 // | SubDelResp 2 | |
1379 // |<---------------------------| |
1381 //-----------------------------------------------------------------------------
1382 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1383 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1386 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1388 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1389 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1392 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1394 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1397 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1398 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1401 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1404 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1405 xappConn1.RecvSubsDelResp(t, deltrans1)
1408 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1409 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1410 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1411 xappConn2.RecvSubsDelResp(t, deltrans2)
1413 //Wait that subs is cleaned
1414 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1416 xappConn1.TestMsgChanEmpty(t)
1417 xappConn2.TestMsgChanEmpty(t)
1418 e2termConn1.TestMsgChanEmpty(t)
1419 mainCtrl.wait_registry_empty(t, 10)
1422 //-----------------------------------------------------------------------------
1423 // TestSubReqAndSubDelNokSameActionParallel
1426 // +-------+ +-------+ +---------+ +---------+
1427 // | xapp2 | | xapp1 | | submgr | | e2term |
1428 // +-------+ +-------+ +---------+ +---------+
1433 // | |------------->| |
1436 // | | |------------->|
1438 // |--------------------------->| |
1440 // | | |<-------------|
1443 // | |<-------------| |
1446 // |<---------------------------| |
1448 //-----------------------------------------------------------------------------
1449 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1450 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1453 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1455 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1457 // E2t: Receive SubsReq (first)
1458 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1461 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1463 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1464 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1465 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1467 // E2t: send SubsFail (first)
1468 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1469 fparams1.Set(crereq1)
1470 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1473 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1475 xappConn2.RecvSubsFail(t, cretrans2)
1477 //Wait that subs is cleaned
1478 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1480 xappConn1.TestMsgChanEmpty(t)
1481 xappConn2.TestMsgChanEmpty(t)
1482 e2termConn1.TestMsgChanEmpty(t)
1483 mainCtrl.wait_registry_empty(t, 10)
1486 //-----------------------------------------------------------------------------
1487 // TestSubReqAndSubDelNoAnswerSameActionParallel
1490 // +-------+ +-------+ +---------+ +---------+
1491 // | xapp2 | | xapp1 | | submgr | | e2term |
1492 // +-------+ +-------+ +---------+ +---------+
1497 // | |------------->| |
1500 // | | |------------->|
1502 // |--------------------------->| |
1505 // | | |------------->|
1508 // | | | SubDelReq |
1509 // | | |------------->|
1511 // | | | SubDelResp |
1512 // | | |<-------------|
1514 //-----------------------------------------------------------------------------
1515 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1516 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1519 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1521 xappConn1.SendSubsReq(t, rparams1, nil)
1523 crereq1, _ := e2termConn1.RecvSubsReq(t)
1526 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1528 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1529 xappConn2.SendSubsReq(t, rparams2, nil)
1530 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1532 //Req1 (retransmitted)
1533 e2termConn1.RecvSubsReq(t)
1535 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1536 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1538 //Wait that subs is cleaned
1539 mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10)
1541 xappConn1.TestMsgChanEmpty(t)
1542 xappConn2.TestMsgChanEmpty(t)
1543 e2termConn1.TestMsgChanEmpty(t)
1544 mainCtrl.wait_registry_empty(t, 15)
1547 //----------------------------- Policy cases ---------------------------------
1548 //-----------------------------------------------------------------------------
1549 // TestSubReqPolicyAndSubDelOk
1552 // +-------+ +---------+ +---------+
1553 // | xapp | | submgr | | e2term |
1554 // +-------+ +---------+ +---------+
1557 // |------------->| |
1560 // | |------------->|
1563 // | |<-------------|
1566 // |<-------------| |
1570 // |------------->| |
1573 // | |------------->|
1576 // | |<-------------|
1579 // |<-------------| |
1581 //-----------------------------------------------------------------------------
1582 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
1583 CaseBegin("TestSubReqAndSubDelOk")
1585 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1587 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1588 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1590 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1591 e2termConn1.SendSubsResp(t, crereq, cremsg)
1592 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1593 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1594 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1596 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1597 xappConn1.RecvSubsDelResp(t, deltrans)
1599 //Wait that subs is cleaned
1600 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1602 xappConn1.TestMsgChanEmpty(t)
1603 xappConn2.TestMsgChanEmpty(t)
1604 e2termConn1.TestMsgChanEmpty(t)
1605 mainCtrl.wait_registry_empty(t, 10)
1608 //-----------------------------------------------------------------------------
1609 // TestSubReqPolicyChangeAndSubDelOk
1612 // +-------+ +---------+ +---------+
1613 // | xapp | | submgr | | e2term |
1614 // +-------+ +---------+ +---------+
1617 // |------------->| |
1620 // | |------------->|
1623 // | |<-------------|
1626 // |<-------------| |
1629 // |------------->| |
1632 // | |------------->|
1635 // | |<-------------|
1638 // |<-------------| |
1641 // |------------->| |
1644 // | |------------->|
1647 // | |<-------------|
1650 // |<-------------| |
1652 //-----------------------------------------------------------------------------
1654 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
1655 CaseBegin("TestSubReqAndSubDelOk")
1657 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1659 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1660 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1662 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1663 e2termConn1.SendSubsResp(t, crereq, cremsg)
1664 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1667 rparams1.Req.RequestId.InstanceId = e2SubsId
1668 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
1669 xappConn1.SendSubsReq(t, rparams1, cretrans)
1671 crereq, cremsg = e2termConn1.RecvSubsReq(t)
1672 e2termConn1.SendSubsResp(t, crereq, cremsg)
1673 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1674 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1675 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1677 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1678 xappConn1.RecvSubsDelResp(t, deltrans)
1680 //Wait that subs is cleaned
1681 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1683 xappConn1.TestMsgChanEmpty(t)
1684 xappConn2.TestMsgChanEmpty(t)
1685 e2termConn1.TestMsgChanEmpty(t)
1686 mainCtrl.wait_registry_empty(t, 10)
1689 //-----------------------------------------------------------------------------
1690 // TestSubReqAndSubDelOkTwoE2termParallel
1693 // +-------+ +---------+ +---------+ +---------+
1694 // | xapp | | submgr | | e2term1 | | e2term2 |
1695 // +-------+ +---------+ +---------+ +---------+
1700 // |------------->| | |
1703 // | |------------->| |
1706 // |------------->| | |
1709 // | |---------------------------->|
1712 // | |<-------------| |
1714 // |<-------------| | |
1716 // | |<----------------------------|
1718 // |<-------------| | |
1720 // | [SUBS 1 DELETE] | |
1722 // | [SUBS 2 DELETE] | |
1725 //-----------------------------------------------------------------------------
1726 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
1727 CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
1730 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1731 xappConn1.SendSubsReq(t, nil, cretrans1)
1732 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1734 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
1735 xappConn1.SendSubsReq(t, nil, cretrans2)
1736 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
1739 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1740 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1743 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
1744 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1747 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1748 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1749 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1750 xappConn1.RecvSubsDelResp(t, deltrans1)
1751 //Wait that subs is cleaned
1752 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1755 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
1756 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
1757 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
1758 xappConn1.RecvSubsDelResp(t, deltrans2)
1759 //Wait that subs is cleaned
1760 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1762 xappConn1.TestMsgChanEmpty(t)
1763 xappConn2.TestMsgChanEmpty(t)
1764 e2termConn1.TestMsgChanEmpty(t)
1765 e2termConn2.TestMsgChanEmpty(t)
1766 mainCtrl.wait_registry_empty(t, 10)
1769 //-----------------------------------------------------------------------------
1770 // TestSubReqInsertAndSubDelOk
1773 // +-------+ +---------+ +---------+
1774 // | xapp | | submgr | | e2term |
1775 // +-------+ +---------+ +---------+
1778 // |------------->| |
1781 // | |------------->|
1784 // | |<-------------|
1787 // |<-------------| |
1791 // |------------->| |
1794 // | |------------->|
1797 // | |<-------------|
1800 // |<-------------| |
1802 //-----------------------------------------------------------------------------
1803 func TestSubReqInsertAndSubDelOk(t *testing.T) {
1804 CaseBegin("TestInsertSubReqAndSubDelOk")
1806 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1808 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeInsert
1809 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1811 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1812 e2termConn1.SendSubsResp(t, crereq, cremsg)
1813 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1814 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1815 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1817 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1818 xappConn1.RecvSubsDelResp(t, deltrans)
1820 //Wait that subs is cleaned
1821 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1823 xappConn1.TestMsgChanEmpty(t)
1824 xappConn2.TestMsgChanEmpty(t)
1825 e2termConn1.TestMsgChanEmpty(t)
1826 mainCtrl.wait_registry_empty(t, 10)
1829 //-----------------------------------------------------------------------------
1830 // TestSubReqRetransmissionWithSameSubIdDiffXid
1832 // This case simulates case where xApp restarts and starts sending same
1833 // subscription requests which have already subscribed successfully
1836 // +-------+ +---------+ +---------+
1837 // | xapp | | submgr | | e2term |
1838 // +-------+ +---------+ +---------+
1841 // |------------->| |
1844 // | |------------->|
1847 // | |<-------------|
1850 // |<-------------| |
1852 // | xApp restart | |
1855 // | (retrans with same xApp generated subid but diff xid)
1856 // |------------->| |
1859 // |<-------------| |
1861 // | [SUBS DELETE] |
1864 //-----------------------------------------------------------------------------
1865 func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) {
1866 CaseBegin("TestSubReqRetransmissionWithSameSubIdDiffXid")
1869 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1870 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1871 e2termConn1.SendSubsResp(t, crereq, cremsg)
1872 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1874 // xApp restart here
1875 // --> artificial delay
1876 <-time.After(1 * time.Second)
1879 cretrans = xappConn1.SendSubsReq(t, nil, nil) //Retransmitted SubReq
1880 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1883 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1884 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1885 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1886 xappConn1.RecvSubsDelResp(t, deltrans)
1888 //Wait that subs is cleaned
1889 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1891 xappConn1.TestMsgChanEmpty(t)
1892 xappConn2.TestMsgChanEmpty(t)
1893 e2termConn1.TestMsgChanEmpty(t)
1894 mainCtrl.wait_registry_empty(t, 10)
1897 //-----------------------------------------------------------------------------
1898 // TestSubReqNokAndSubDelOkWithRestartInMiddle
1901 // +-------+ +---------+ +---------+
1902 // | xapp | | submgr | | e2term |
1903 // +-------+ +---------+ +---------+
1906 // |------------->| |
1909 // | |------------->|
1914 // | Submgr restart |
1918 // | |------------->|
1921 // | |<-------------|
1924 //-----------------------------------------------------------------------------
1926 func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
1927 CaseBegin("TestSubReqNokAndSubDelOkWithRestartInMiddle")
1929 // Remove possible existing subscrition
1930 mainCtrl.removeExistingSubscriptions(t)
1932 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
1933 xappConn1.SendSubsReq(t, nil, nil)
1934 e2termConn1.RecvSubsReq(t)
1935 mainCtrl.SetResetTestFlag(t, false)
1937 resp, _ := xapp.Subscription.QuerySubscriptions()
1938 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1939 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560"})
1940 e2SubsId := uint32(resp[0].SubscriptionID)
1941 t.Logf("e2SubsId = %v", e2SubsId)
1943 mainCtrl.SimulateRestart(t) // This will trigger sending of SubDelReq
1945 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1946 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1948 // Wait that subs is cleaned
1949 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1951 xappConn1.TestMsgChanEmpty(t)
1952 xappConn2.TestMsgChanEmpty(t)
1953 e2termConn1.TestMsgChanEmpty(t)
1954 mainCtrl.wait_registry_empty(t, 10)
1957 //-----------------------------------------------------------------------------
1958 // TestSubReqAndSubDelOkWithRestartInMiddle
1961 // +-------+ +---------+ +---------+
1962 // | xapp | | submgr | | e2term |
1963 // +-------+ +---------+ +---------+
1966 // |------------->| |
1969 // | |------------->|
1972 // | |<-------------|
1975 // |<-------------| |
1978 // | Submgr restart |
1981 // |------------->| |
1984 // | |------------->|
1987 // | |<-------------|
1990 // |<-------------| |
1992 //-----------------------------------------------------------------------------
1994 func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
1995 CaseBegin("TestSubReqAndSubDelOkWithRestartInMiddle")
1997 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1998 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1999 e2termConn1.SendSubsResp(t, crereq, cremsg)
2000 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2002 // Check subscription
2003 resp, _ := xapp.Subscription.QuerySubscriptions()
2004 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2005 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2006 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560"})
2008 mainCtrl.SimulateRestart(t)
2010 // Check that subscription is restored correctly after restart
2011 resp, _ = xapp.Subscription.QuerySubscriptions()
2012 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2013 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2014 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560"})
2016 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2017 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2018 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2019 xappConn1.RecvSubsDelResp(t, deltrans)
2021 //Wait that subs is cleaned
2022 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2024 xappConn1.TestMsgChanEmpty(t)
2025 xappConn2.TestMsgChanEmpty(t)
2026 e2termConn1.TestMsgChanEmpty(t)
2027 mainCtrl.wait_registry_empty(t, 10)
2030 //-----------------------------------------------------------------------------
2031 // TestSubReqAndSubDelOkSameActionWithRestartsInMiddle
2034 // +-------+ +-------+ +---------+ +---------+
2035 // | xapp2 | | xapp1 | | submgr | | e2term |
2036 // +-------+ +-------+ +---------+ +---------+
2041 // | |------------->| |
2044 // | | |------------->|
2046 // | | |<-------------|
2048 // | |<-------------| |
2051 // | submgr restart |
2056 // |--------------------------->| |
2059 // |<---------------------------| |
2061 // | | SubDelReq 1 | |
2062 // | |------------->| |
2064 // | | SubDelResp 1 | |
2065 // | |<-------------| |
2069 // | submgr restart |
2072 // | SubDelReq 2 | |
2073 // |--------------------------->| |
2075 // | | | SubDelReq 2 |
2076 // | | |------------->|
2078 // | | | SubDelReq 2 |
2079 // | | |------------->|
2081 // | SubDelResp 2 | |
2082 // |<---------------------------| |
2084 //-----------------------------------------------------------------------------
2086 func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
2087 CaseBegin("TestSubReqAndSubDelOkSameActionWithRestartsInMiddle")
2090 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2092 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2093 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2094 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2095 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2098 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2100 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2101 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
2103 // Check subscription
2104 resp, _ := xapp.Subscription.QuerySubscriptions() ////////////////////////////////
2105 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2106 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2107 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560", "localhost:13660"})
2109 mainCtrl.SimulateRestart(t)
2111 // Check that subscription is restored correctly after restart
2112 resp, _ = xapp.Subscription.QuerySubscriptions()
2113 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2114 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2115 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560", "localhost:13660"})
2118 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2119 xapp.Logger.Debug("xappConn1.RecvSubsDelResp")
2120 xappConn1.RecvSubsDelResp(t, deltrans1)
2121 xapp.Logger.Debug("xappConn1.RecvSubsDelResp received")
2123 mainCtrl.SimulateRestart(t)
2124 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2127 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
2128 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2130 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2131 xappConn2.RecvSubsDelResp(t, deltrans2)
2133 //Wait that subs is cleaned
2134 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2136 xappConn1.TestMsgChanEmpty(t)
2137 xappConn2.TestMsgChanEmpty(t)
2138 e2termConn1.TestMsgChanEmpty(t)
2139 mainCtrl.wait_registry_empty(t, 10)