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.SetTimesCounterWillBeAdded(cSubReqFromXapp, 1)
60 mainCtrl.SetTimesCounterWillBeAdded(cRouteCreateFail, 1)
61 mainCtrl.GetCounterValuesBefore(t)
63 waiter := rtmgrHttp.AllocNextEvent(false)
64 newSubsId := mainCtrl.get_registry_next_subid(t)
65 xappConn1.SendSubsReq(t, nil, nil)
68 //Wait that subs is cleaned
69 mainCtrl.wait_subs_clean(t, newSubsId, 10)
71 xappConn1.TestMsgChanEmpty(t)
72 xappConn2.TestMsgChanEmpty(t)
73 e2termConn1.TestMsgChanEmpty(t)
74 mainCtrl.wait_registry_empty(t, 10)
76 <-time.After(1 * time.Second)
77 mainCtrl.VerifyCounterValues(t)
80 //-----------------------------------------------------------------------------
81 // TestSubReqAndRouteUpdateNok
84 // +-------+ +-------+ +---------+ +---------+
85 // | xapp2 | | xapp1 | | submgr | | rtmgr |
86 // +-------+ +-------+ +---------+ +---------+
88 // | [SUBS CREATE] | |
92 // | SubReq (mergeable) | |
93 // |--------------------------->| | |
95 // | | | RouteUpdate |
96 // | | |------------->|
98 // | | | RouteUpdate |
100 // | | |<-------------|
102 // | [SUBS INT DELETE] | |
105 // | [SUBS DELETE] | |
107 func TestSubReqAndRouteUpdateNok(t *testing.T) {
108 CaseBegin("TestSubReqAndRouteUpdateNok")
110 // Init counter check
111 mainCtrl.SetTimesCounterWillBeAdded(cSubReqFromXapp, 2)
112 mainCtrl.SetTimesCounterWillBeAdded(cSubReqToE2, 1)
113 mainCtrl.SetTimesCounterWillBeAdded(cSubRespFromE2, 1)
114 mainCtrl.SetTimesCounterWillBeAdded(cSubRespToXapp, 1)
115 mainCtrl.SetTimesCounterWillBeAdded(cRouteCreateUpdateFail, 1)
117 mainCtrl.SetTimesCounterWillBeAdded(cSubDelReqFromXapp, 1)
118 mainCtrl.SetTimesCounterWillBeAdded(cSubDelReqToE2, 1)
119 mainCtrl.SetTimesCounterWillBeAdded(cSubDelRespFromE2, 1)
120 mainCtrl.SetTimesCounterWillBeAdded(cSubDelRespToXapp, 1)
121 mainCtrl.GetCounterValuesBefore(t)
123 cretrans := xappConn1.SendSubsReq(t, nil, nil)
124 crereq, cremsg := e2termConn1.RecvSubsReq(t)
125 e2termConn1.SendSubsResp(t, crereq, cremsg)
126 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
128 resp, _ := xapp.Subscription.QuerySubscriptions()
129 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
130 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
131 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560"})
133 waiter := rtmgrHttp.AllocNextEvent(false)
134 newSubsId := mainCtrl.get_registry_next_subid(t)
135 xappConn2.SendSubsReq(t, nil, nil)
138 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
139 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
141 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
142 xappConn1.RecvSubsDelResp(t, deltrans)
144 //Wait that subs is cleaned
145 mainCtrl.wait_subs_clean(t, newSubsId, 10)
146 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
148 xappConn1.TestMsgChanEmpty(t)
149 xappConn2.TestMsgChanEmpty(t)
150 e2termConn1.TestMsgChanEmpty(t)
151 mainCtrl.wait_registry_empty(t, 10)
153 mainCtrl.VerifyCounterValues(t)
156 //-----------------------------------------------------------------------------
157 // TestSubDelReqAndRouteDeleteNok
160 // +-------+ +---------+ +---------+ +---------+
161 // | xapp | | submgr | | e2term | | rtmgr |
162 // +-------+ +---------+ +---------+ +---------+
164 // | [SUBS CREATE] | |
169 // |------------->| | |
171 // | |------------->| |
173 // | |<-------------| |
175 // |<-------------| | |
176 // | | RouteDelete | |
177 // | |---------------------------->|
179 // | | RouteDelete | |
180 // | | status:400 | |
181 // | |<----------------------------|
183 func TestSubDelReqAndRouteDeleteNok(t *testing.T) {
184 CaseBegin("TestSubDelReqAndRouteDeleteNok")
186 // Init counter check
187 mainCtrl.SetTimesCounterWillBeAdded(cSubReqFromXapp, 1)
188 mainCtrl.SetTimesCounterWillBeAdded(cSubReqToE2, 1)
189 mainCtrl.SetTimesCounterWillBeAdded(cSubRespFromE2, 1)
190 mainCtrl.SetTimesCounterWillBeAdded(cSubRespToXapp, 1)
192 mainCtrl.SetTimesCounterWillBeAdded(cSubDelReqFromXapp, 1)
193 mainCtrl.SetTimesCounterWillBeAdded(cRouteDeleteFail, 1)
194 mainCtrl.SetTimesCounterWillBeAdded(cSubDelReqToE2, 1)
195 mainCtrl.SetTimesCounterWillBeAdded(cSubDelRespFromE2, 1)
196 mainCtrl.SetTimesCounterWillBeAdded(cSubDelRespToXapp, 1)
197 mainCtrl.GetCounterValuesBefore(t)
199 cretrans := xappConn1.SendSubsReq(t, nil, nil)
200 crereq, cremsg := e2termConn1.RecvSubsReq(t)
201 e2termConn1.SendSubsResp(t, crereq, cremsg)
202 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
204 resp, _ := xapp.Subscription.QuerySubscriptions()
205 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
206 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
207 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560"})
209 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
210 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
212 waiter := rtmgrHttp.AllocNextEvent(false)
213 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
216 xappConn1.RecvSubsDelResp(t, deltrans)
218 //Wait that subs is cleaned
219 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
221 xappConn1.TestMsgChanEmpty(t)
222 xappConn2.TestMsgChanEmpty(t)
223 e2termConn1.TestMsgChanEmpty(t)
224 mainCtrl.wait_registry_empty(t, 10)
226 mainCtrl.VerifyCounterValues(t)
229 //-----------------------------------------------------------------------------
230 // TestSubMergeDelAndRouteUpdateNok
232 // +-------+ +-------+ +---------+ +---------+
233 // | xapp2 | | xapp1 | | submgr | | e2term |
234 // +-------+ +-------+ +---------+ +---------+
239 // | |------------->| |
242 // | | |------------->|
244 // | | |<-------------|
246 // | |<-------------| |
249 // |--------------------------->| |
252 // |<---------------------------| |
254 // | | SubDelReq 1 | |
255 // | |------------->| |
256 // | | | RouteUpdate |
257 // | | |-----> rtmgr |
259 // | | | RouteUpdate |
260 // | | | status:400 |
261 // | | |<----- rtmgr |
263 // | | SubDelResp 1 | |
264 // | |<-------------| |
267 // |--------------------------->| |
269 // | | | SubDelReq 2 |
270 // | | |------------->|
272 // | | | SubDelReq 2 |
273 // | | |------------->|
275 // | SubDelResp 2 | |
276 // |<---------------------------| |
278 //-----------------------------------------------------------------------------
279 func TestSubMergeDelAndRouteUpdateNok(t *testing.T) {
280 CaseBegin("TestSubMergeDelAndRouteUpdateNok")
282 // Init counter check
283 mainCtrl.SetTimesCounterWillBeAdded(cSubReqFromXapp, 2)
284 mainCtrl.SetTimesCounterWillBeAdded(cSubReqToE2, 1)
285 mainCtrl.SetTimesCounterWillBeAdded(cSubRespFromE2, 1)
286 mainCtrl.SetTimesCounterWillBeAdded(cSubRespToXapp, 2)
288 mainCtrl.SetTimesCounterWillBeAdded(cSubDelReqFromXapp, 2)
289 mainCtrl.SetTimesCounterWillBeAdded(cRouteDeleteUpdateFail, 1)
290 mainCtrl.SetTimesCounterWillBeAdded(cSubDelReqToE2, 1)
291 mainCtrl.SetTimesCounterWillBeAdded(cSubDelRespFromE2, 1)
292 mainCtrl.SetTimesCounterWillBeAdded(cSubDelRespToXapp, 2)
293 mainCtrl.GetCounterValuesBefore(t)
296 rparams1 := &teststube2ap.E2StubSubsReqParams{}
298 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
299 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
300 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
301 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
304 rparams2 := &teststube2ap.E2StubSubsReqParams{}
306 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
307 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
309 resp, _ := xapp.Subscription.QuerySubscriptions()
310 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
311 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
312 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560", "localhost:13660"})
315 waiter := rtmgrHttp.AllocNextEvent(false)
316 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
319 xappConn1.RecvSubsDelResp(t, deltrans1)
322 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
323 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
324 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
325 xappConn2.RecvSubsDelResp(t, deltrans2)
326 //Wait that subs is cleaned
327 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
329 xappConn1.TestMsgChanEmpty(t)
330 xappConn2.TestMsgChanEmpty(t)
331 e2termConn1.TestMsgChanEmpty(t)
332 mainCtrl.wait_registry_empty(t, 10)
334 mainCtrl.VerifyCounterValues(t)
337 //-----------------------------------------------------------------------------
339 //-----------------------------------------------------------------------------
340 // TestSubReqAndSubDelOk
343 // +-------+ +---------+ +---------+
344 // | xapp | | submgr | | e2term |
345 // +-------+ +---------+ +---------+
348 // |------------->| |
351 // | |------------->|
354 // | |<-------------|
357 // |<-------------| |
361 // |------------->| |
364 // | |------------->|
367 // | |<-------------|
370 // |<-------------| |
372 //-----------------------------------------------------------------------------
373 func TestSubReqAndSubDelOk(t *testing.T) {
374 CaseBegin("TestSubReqAndSubDelOk")
376 // Init counter check
377 mainCtrl.SetTimesCounterWillBeAdded(cSubReqFromXapp, 1)
378 mainCtrl.SetTimesCounterWillBeAdded(cSubReqToE2, 1)
379 mainCtrl.SetTimesCounterWillBeAdded(cSubRespFromE2, 1)
380 mainCtrl.SetTimesCounterWillBeAdded(cSubRespToXapp, 1)
382 mainCtrl.SetTimesCounterWillBeAdded(cSubDelReqFromXapp, 1)
383 mainCtrl.SetTimesCounterWillBeAdded(cSubDelReqToE2, 1)
384 mainCtrl.SetTimesCounterWillBeAdded(cSubDelRespFromE2, 1)
385 mainCtrl.SetTimesCounterWillBeAdded(cSubDelRespToXapp, 1)
386 mainCtrl.GetCounterValuesBefore(t)
388 cretrans := xappConn1.SendSubsReq(t, nil, nil)
389 crereq, cremsg := e2termConn1.RecvSubsReq(t)
390 e2termConn1.SendSubsResp(t, crereq, cremsg)
391 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
393 resp, _ := xapp.Subscription.QuerySubscriptions()
394 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
395 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
396 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560"})
398 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
399 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
401 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
402 xappConn1.RecvSubsDelResp(t, deltrans)
404 //Wait that subs is cleaned
405 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
407 xappConn1.TestMsgChanEmpty(t)
408 xappConn2.TestMsgChanEmpty(t)
409 e2termConn1.TestMsgChanEmpty(t)
410 mainCtrl.wait_registry_empty(t, 10)
412 mainCtrl.VerifyCounterValues(t)
415 //-----------------------------------------------------------------------------
416 // TestSubReqRetransmission
419 // +-------+ +---------+ +---------+
420 // | xapp | | submgr | | e2term |
421 // +-------+ +---------+ +---------+
424 // |------------->| |
427 // | |------------->|
431 // |------------->| |
434 // | |<-------------|
437 // |<-------------| |
442 //-----------------------------------------------------------------------------
443 func TestSubReqRetransmission(t *testing.T) {
444 CaseBegin("TestSubReqRetransmission")
447 cretrans := xappConn1.SendSubsReq(t, nil, nil)
448 crereq, cremsg := e2termConn1.RecvSubsReq(t)
450 seqBef := mainCtrl.get_msgcounter(t)
451 xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq
452 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
454 // hack as there is no real way to see has message be handled.
455 // Previuos counter check just tells that is has been received by submgr
456 // --> artificial delay
457 <-time.After(1 * time.Second)
458 e2termConn1.SendSubsResp(t, crereq, cremsg)
459 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
462 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
463 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
464 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
465 xappConn1.RecvSubsDelResp(t, deltrans)
467 //Wait that subs is cleaned
468 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
470 xappConn1.TestMsgChanEmpty(t)
471 xappConn2.TestMsgChanEmpty(t)
472 e2termConn1.TestMsgChanEmpty(t)
473 mainCtrl.wait_registry_empty(t, 10)
476 //-----------------------------------------------------------------------------
477 // TestSubDelReqRetransmission
480 // +-------+ +---------+ +---------+
481 // | xapp | | submgr | | e2term |
482 // +-------+ +---------+ +---------+
488 // |------------->| |
491 // | |------------->|
496 // |------------->| |
499 // | |<-------------|
502 // |<-------------| |
504 //-----------------------------------------------------------------------------
505 func TestSubDelReqRetransmission(t *testing.T) {
506 CaseBegin("TestSubDelReqRetransmission")
509 cretrans := xappConn1.SendSubsReq(t, nil, nil)
510 crereq, cremsg := e2termConn1.RecvSubsReq(t)
511 e2termConn1.SendSubsResp(t, crereq, cremsg)
512 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
515 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
516 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
518 seqBef := mainCtrl.get_msgcounter(t)
519 xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq
520 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
522 // hack as there is no real way to see has message be handled.
523 // Previuos counter check just tells that is has been received by submgr
524 // --> artificial delay
525 <-time.After(1 * time.Second)
527 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
528 xappConn1.RecvSubsDelResp(t, deltrans)
530 //Wait that subs is cleaned
531 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
533 xappConn1.TestMsgChanEmpty(t)
534 xappConn2.TestMsgChanEmpty(t)
535 e2termConn1.TestMsgChanEmpty(t)
536 mainCtrl.wait_registry_empty(t, 10)
539 //-----------------------------------------------------------------------------
540 // TestSubDelReqCollision
543 // +-------+ +---------+ +---------+
544 // | xapp | | submgr | | e2term |
545 // +-------+ +---------+ +---------+
551 // |------------->| |
554 // | |------------->|
559 // |------------->| |
561 // | | SubDelResp 1 |
562 // | |<-------------|
564 // | SubDelResp 1 | |
565 // |<-------------| |
567 // | SubDelResp 2 | |
568 // |<-------------| |
570 //-----------------------------------------------------------------------------
572 func TestSubDelReqCollision(t *testing.T) {
573 CaseBegin("TestSubDelReqCollision")
576 cretrans := xappConn1.SendSubsReq(t, nil, nil)
577 crereq, cremsg := e2termConn1.RecvSubsReq(t)
578 e2termConn1.SendSubsResp(t, crereq, cremsg)
579 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
582 xappConn1.SendSubsDelReq(t, nil, e2SubsId)
583 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
585 // Subs Delete colliding
586 seqBef := mainCtrl.get_msgcounter(t)
587 deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
588 xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq
589 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
591 // hack as there is no real way to see has message be handled.
592 // Previuos counter check just tells that is has been received by submgr
593 // --> artificial delay
594 <-time.After(1 * time.Second)
596 // Del resp for first and second
597 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
599 // don't care in which order responses are received
600 xappConn1.RecvSubsDelResp(t, nil)
601 xappConn1.RecvSubsDelResp(t, nil)
603 //Wait that subs is cleaned
604 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
606 xappConn1.TestMsgChanEmpty(t)
607 xappConn2.TestMsgChanEmpty(t)
608 e2termConn1.TestMsgChanEmpty(t)
609 mainCtrl.wait_registry_empty(t, 10)
612 //-----------------------------------------------------------------------------
613 // TestSubReqAndSubDelOkTwoParallel
616 // +-------+ +-------+ +---------+ +---------+
617 // | xapp | | xapp | | submgr | | e2term |
618 // +-------+ +-------+ +---------+ +---------+
623 // | |------------->| |
626 // | | |------------->|
629 // |------------------------>| |
632 // | | |------------->|
635 // | | |<-------------|
637 // | |<-------------| |
640 // | | |<-------------|
642 // |<------------------------| |
644 // | | [SUBS 1 DELETE] |
646 // | | [SUBS 2 DELETE] |
649 //-----------------------------------------------------------------------------
650 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
651 CaseBegin("TestSubReqAndSubDelOkTwoParallel")
654 rparams1 := &teststube2ap.E2StubSubsReqParams{}
656 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
657 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
660 rparams2 := &teststube2ap.E2StubSubsReqParams{}
663 rparams2.Req.EventTriggerDefinition.Data.Length = 1
664 rparams2.Req.EventTriggerDefinition.Data.Data = make([]uint8, rparams2.Req.EventTriggerDefinition.Data.Length)
665 rparams2.Req.EventTriggerDefinition.Data.Data[0] = 2
667 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
668 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
671 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
672 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
675 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
676 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
679 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
680 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
681 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
682 xappConn1.RecvSubsDelResp(t, deltrans1)
683 //Wait that subs is cleaned
684 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
687 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
688 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
689 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
690 xappConn2.RecvSubsDelResp(t, deltrans2)
691 //Wait that subs is cleaned
692 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
694 xappConn1.TestMsgChanEmpty(t)
695 xappConn2.TestMsgChanEmpty(t)
696 e2termConn1.TestMsgChanEmpty(t)
697 mainCtrl.wait_registry_empty(t, 10)
700 //-----------------------------------------------------------------------------
701 // TestSameSubsDiffRan
702 // Same subscription to different RANs
705 // +-------+ +---------+ +---------+
706 // | xapp | | submgr | | e2term |
707 // +-------+ +---------+ +---------+
712 // |------------->| |
715 // | |------------->|
718 // | |<-------------|
721 // |<-------------| |
724 // |------------->| |
727 // | |------------->|
730 // | |<-------------|
733 // |<-------------| |
735 // | [SUBS r1 DELETE] |
737 // | [SUBS r2 DELETE] |
740 //-----------------------------------------------------------------------------
741 func TestSameSubsDiffRan(t *testing.T) {
742 CaseBegin("TestSameSubsDiffRan")
745 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
746 xappConn1.SendSubsReq(t, nil, cretrans1)
747 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
748 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
749 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
752 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
753 xappConn1.SendSubsReq(t, nil, cretrans2)
754 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
755 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
756 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
759 deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
760 xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
761 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
762 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
763 xappConn1.RecvSubsDelResp(t, deltrans1)
764 //Wait that subs is cleaned
765 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
768 deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
769 xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
770 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
771 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
772 xappConn1.RecvSubsDelResp(t, deltrans2)
773 //Wait that subs is cleaned
774 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
776 xappConn1.TestMsgChanEmpty(t)
777 xappConn2.TestMsgChanEmpty(t)
778 e2termConn1.TestMsgChanEmpty(t)
779 mainCtrl.wait_registry_empty(t, 10)
782 //-----------------------------------------------------------------------------
783 // TestSubReqRetryInSubmgr
786 // +-------+ +---------+ +---------+
787 // | xapp | | submgr | | e2term |
788 // +-------+ +---------+ +---------+
791 // |------------->| |
794 // | |------------->|
798 // | |------------->|
801 // | |<-------------|
804 // |<-------------| |
809 //-----------------------------------------------------------------------------
811 func TestSubReqRetryInSubmgr(t *testing.T) {
813 CaseBegin("TestSubReqRetryInSubmgr start")
814 mainCtrl.SetTimesCounterWillBeAdded(cSubReqFromXapp, 1)
815 mainCtrl.SetTimesCounterWillBeAdded(cSubReqToE2, 1)
816 mainCtrl.SetTimesCounterWillBeAdded(cSubReReqToE2, 1)
817 mainCtrl.SetTimesCounterWillBeAdded(cSubRespFromE2, 1)
818 mainCtrl.SetTimesCounterWillBeAdded(cSubRespToXapp, 1)
819 mainCtrl.SetTimesCounterWillBeAdded(cSubDelReqFromXapp, 1)
820 mainCtrl.SetTimesCounterWillBeAdded(cSubDelReqToE2, 1)
821 mainCtrl.SetTimesCounterWillBeAdded(cSubDelRespFromE2, 1)
822 mainCtrl.SetTimesCounterWillBeAdded(cSubDelRespToXapp, 1)
823 mainCtrl.GetCounterValuesBefore(t)
825 // Xapp: Send SubsReq
826 cretrans := xappConn1.SendSubsReq(t, nil, nil)
828 // E2t: Receive 1st SubsReq
829 e2termConn1.RecvSubsReq(t)
831 // E2t: Receive 2nd SubsReq and send SubsResp
832 crereq, cremsg := e2termConn1.RecvSubsReq(t)
833 e2termConn1.SendSubsResp(t, crereq, cremsg)
835 // Xapp: Receive SubsResp
836 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
838 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
839 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
840 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
841 xappConn1.RecvSubsDelResp(t, deltrans)
843 // Wait that subs is cleaned
844 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
846 xappConn1.TestMsgChanEmpty(t)
847 xappConn2.TestMsgChanEmpty(t)
848 e2termConn1.TestMsgChanEmpty(t)
849 mainCtrl.wait_registry_empty(t, 10)
851 mainCtrl.VerifyCounterValues(t)
854 //-----------------------------------------------------------------------------
855 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
858 // +-------+ +---------+ +---------+
859 // | xapp | | submgr | | e2term |
860 // +-------+ +---------+ +---------+
863 // |------------->| |
866 // | |------------->|
870 // | |------------->|
873 // | |------------->|
876 // | |<-------------|
879 //-----------------------------------------------------------------------------
881 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
883 CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
884 mainCtrl.SetTimesCounterWillBeAdded(cSubReqFromXapp, 1)
885 mainCtrl.SetTimesCounterWillBeAdded(cSubReqToE2, 1)
886 mainCtrl.SetTimesCounterWillBeAdded(cSubReReqToE2, 1)
887 mainCtrl.SetTimesCounterWillBeAdded(cSubReqTimerExpiry, 2)
888 mainCtrl.SetTimesCounterWillBeAdded(cSubDelReqToE2, 1)
889 mainCtrl.SetTimesCounterWillBeAdded(cSubDelRespFromE2, 1)
890 mainCtrl.GetCounterValuesBefore(t)
892 // Xapp: Send SubsReq
893 xappConn1.SendSubsReq(t, nil, nil)
895 // E2t: Receive 1st SubsReq
896 e2termConn1.RecvSubsReq(t)
898 // E2t: Receive 2nd SubsReq
899 e2termConn1.RecvSubsReq(t)
901 // E2t: Send receive SubsDelReq and send SubsResp
902 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
903 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
905 // Wait that subs is cleaned
906 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 10)
908 xappConn1.TestMsgChanEmpty(t)
909 xappConn2.TestMsgChanEmpty(t)
910 e2termConn1.TestMsgChanEmpty(t)
911 mainCtrl.wait_registry_empty(t, 10)
913 mainCtrl.VerifyCounterValues(t)
916 //-----------------------------------------------------------------------------
917 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
920 // +-------+ +---------+ +---------+
921 // | xapp | | submgr | | e2term |
922 // +-------+ +---------+ +---------+
925 // |------------->| |
928 // | |------------->|
932 // | |------------->|
935 // | |------------->|
939 // | |------------->|
943 //-----------------------------------------------------------------------------
945 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
947 CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
948 mainCtrl.SetTimesCounterWillBeAdded(cSubReqFromXapp, 1)
949 mainCtrl.SetTimesCounterWillBeAdded(cSubReqToE2, 1)
950 mainCtrl.SetTimesCounterWillBeAdded(cSubReReqToE2, 1)
951 mainCtrl.SetTimesCounterWillBeAdded(cSubReqTimerExpiry, 2)
952 mainCtrl.SetTimesCounterWillBeAdded(cSubDelReqToE2, 1)
953 mainCtrl.SetTimesCounterWillBeAdded(cSubDelReqTimerExpiry, 2)
954 mainCtrl.GetCounterValuesBefore(t)
956 // Xapp: Send SubsReq
957 xappConn1.SendSubsReq(t, nil, nil)
959 // E2t: Receive 1st SubsReq
960 e2termConn1.RecvSubsReq(t)
962 // E2t: Receive 2nd SubsReq
963 e2termConn1.RecvSubsReq(t)
965 // E2t: Receive 1st SubsDelReq
966 e2termConn1.RecvSubsDelReq(t)
968 // E2t: Receive 2nd SubsDelReq
969 delreq, _ := e2termConn1.RecvSubsDelReq(t)
971 // Wait that subs is cleaned
972 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 15)
974 xappConn1.TestMsgChanEmpty(t)
975 xappConn2.TestMsgChanEmpty(t)
976 e2termConn1.TestMsgChanEmpty(t)
977 mainCtrl.wait_registry_empty(t, 10)
979 mainCtrl.VerifyCounterValues(t)
982 //-----------------------------------------------------------------------------
983 // TestSubReqSubFailRespInSubmgr
986 // +-------+ +---------+ +---------+
987 // | xapp | | submgr | | e2term |
988 // +-------+ +---------+ +---------+
991 // |------------->| |
994 // | |------------->|
997 // | |<-------------|
1000 // | |------------->|
1003 // | |<-------------|
1006 // |<-------------| |
1009 //-----------------------------------------------------------------------------
1011 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1013 CaseBegin("TestSubReqSubFailRespInSubmgr start")
1014 mainCtrl.SetTimesCounterWillBeAdded(cSubReqFromXapp, 1)
1015 mainCtrl.SetTimesCounterWillBeAdded(cSubReqToE2, 1)
1016 mainCtrl.SetTimesCounterWillBeAdded(cSubFailFromE2, 1)
1017 mainCtrl.SetTimesCounterWillBeAdded(cSubDelReqToE2, 1)
1018 mainCtrl.SetTimesCounterWillBeAdded(cSubDelRespFromE2, 1)
1019 mainCtrl.SetTimesCounterWillBeAdded(cSubFailToXapp, 1)
1020 mainCtrl.GetCounterValuesBefore(t)
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 // E2t: Receive SubsDelReq and send SubsDelResp (internal first)
1032 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1033 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1035 // Xapp: Receive SubsFail
1036 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
1038 // Wait that subs is cleaned
1039 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1041 xappConn1.TestMsgChanEmpty(t)
1042 xappConn2.TestMsgChanEmpty(t)
1043 e2termConn1.TestMsgChanEmpty(t)
1044 mainCtrl.wait_registry_empty(t, 10)
1046 mainCtrl.VerifyCounterValues(t)
1049 //-----------------------------------------------------------------------------
1050 // TestSubDelReqRetryInSubmgr
1053 // +-------+ +---------+ +---------+
1054 // | xapp | | submgr | | e2term |
1055 // +-------+ +---------+ +---------+
1057 // | [SUBS CREATE] |
1061 // |------------->| |
1064 // | |------------->|
1067 // | |------------->|
1070 // | |<-------------|
1073 // |<-------------| |
1075 //-----------------------------------------------------------------------------
1077 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1079 CaseBegin("TestSubDelReqRetryInSubmgr start")
1082 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1083 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1084 e2termConn1.SendSubsResp(t, crereq, cremsg)
1085 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1088 // Xapp: Send SubsDelReq
1089 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1091 // E2t: Receive 1st SubsDelReq
1092 e2termConn1.RecvSubsDelReq(t)
1094 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1095 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1096 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1098 // Xapp: Receive SubsDelResp
1099 xappConn1.RecvSubsDelResp(t, deltrans)
1101 // Wait that subs is cleaned
1102 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1104 xappConn1.TestMsgChanEmpty(t)
1105 xappConn2.TestMsgChanEmpty(t)
1106 e2termConn1.TestMsgChanEmpty(t)
1107 mainCtrl.wait_registry_empty(t, 10)
1110 //-----------------------------------------------------------------------------
1111 // TestSubDelReqTwoRetriesNoRespInSubmgr
1114 // +-------+ +---------+ +---------+
1115 // | xapp | | submgr | | e2term |
1116 // +-------+ +---------+ +---------+
1118 // | [SUBS CREATE] |
1122 // |------------->| |
1125 // | |------------->|
1128 // | |------------->|
1132 // |<-------------| |
1134 //-----------------------------------------------------------------------------
1136 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1138 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
1141 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1142 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1143 e2termConn1.SendSubsResp(t, crereq, cremsg)
1144 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1147 // Xapp: Send SubsDelReq
1148 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1150 // E2t: Receive 1st SubsDelReq
1151 e2termConn1.RecvSubsDelReq(t)
1153 // E2t: Receive 2nd SubsDelReq
1154 e2termConn1.RecvSubsDelReq(t)
1156 // Xapp: Receive SubsDelResp
1157 xappConn1.RecvSubsDelResp(t, deltrans)
1159 // Wait that subs is cleaned
1160 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1162 xappConn1.TestMsgChanEmpty(t)
1163 xappConn2.TestMsgChanEmpty(t)
1164 e2termConn1.TestMsgChanEmpty(t)
1165 mainCtrl.wait_registry_empty(t, 10)
1168 //-----------------------------------------------------------------------------
1169 // TestSubDelReqSubDelFailRespInSubmgr
1172 // +-------+ +---------+ +---------+
1173 // | xapp | | submgr | | e2term |
1174 // +-------+ +---------+ +---------+
1176 // | [SUBS CREATE] |
1180 // |------------->| |
1183 // | |------------->|
1186 // | |<-------------|
1189 // |<-------------| |
1192 //-----------------------------------------------------------------------------
1194 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1196 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1197 mainCtrl.SetTimesCounterWillBeAdded(cSubReqFromXapp, 1)
1198 mainCtrl.SetTimesCounterWillBeAdded(cSubReqToE2, 1)
1199 mainCtrl.SetTimesCounterWillBeAdded(cSubRespFromE2, 1)
1200 mainCtrl.SetTimesCounterWillBeAdded(cSubRespToXapp, 1)
1201 mainCtrl.SetTimesCounterWillBeAdded(cSubDelReqFromXapp, 1)
1202 mainCtrl.SetTimesCounterWillBeAdded(cSubDelReqToE2, 1)
1203 mainCtrl.SetTimesCounterWillBeAdded(cSubDelFailFromE2, 1)
1204 mainCtrl.SetTimesCounterWillBeAdded(cSubDelRespToXapp, 1)
1205 mainCtrl.GetCounterValuesBefore(t)
1208 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1209 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1210 e2termConn1.SendSubsResp(t, crereq, cremsg)
1211 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1213 // Xapp: Send SubsDelReq
1214 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1216 // E2t: Send receive SubsDelReq and send SubsDelFail
1217 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1218 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1220 // Xapp: Receive SubsDelResp
1221 xappConn1.RecvSubsDelResp(t, deltrans)
1223 // Wait that subs is cleaned
1224 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1226 xappConn1.TestMsgChanEmpty(t)
1227 xappConn2.TestMsgChanEmpty(t)
1228 e2termConn1.TestMsgChanEmpty(t)
1229 mainCtrl.wait_registry_empty(t, 10)
1231 mainCtrl.VerifyCounterValues(t)
1234 //-----------------------------------------------------------------------------
1235 // TestSubReqAndSubDelOkSameAction
1238 // +-------+ +-------+ +---------+ +---------+
1239 // | xapp2 | | xapp1 | | submgr | | e2term |
1240 // +-------+ +-------+ +---------+ +---------+
1245 // | |------------->| |
1248 // | | |------------->|
1250 // | | |<-------------|
1252 // | |<-------------| |
1255 // |--------------------------->| |
1258 // |<---------------------------| |
1260 // | | SubDelReq 1 | |
1261 // | |------------->| |
1263 // | | SubDelResp 1 | |
1264 // | |<-------------| |
1266 // | SubDelReq 2 | |
1267 // |--------------------------->| |
1269 // | | | SubDelReq 2 |
1270 // | | |------------->|
1272 // | | | SubDelReq 2 |
1273 // | | |------------->|
1275 // | SubDelResp 2 | |
1276 // |<---------------------------| |
1278 //-----------------------------------------------------------------------------
1279 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
1280 CaseBegin("TestSubReqAndSubDelOkSameAction")
1282 // Init counter check
1283 mainCtrl.SetTimesCounterWillBeAdded(cSubReqFromXapp, 2)
1284 mainCtrl.SetTimesCounterWillBeAdded(cSubReqToE2, 1)
1285 mainCtrl.SetTimesCounterWillBeAdded(cSubRespFromE2, 1)
1286 mainCtrl.SetTimesCounterWillBeAdded(cSubRespToXapp, 2)
1287 mainCtrl.SetTimesCounterWillBeAdded(cMergedSubscriptions, 1)
1288 mainCtrl.SetTimesCounterWillBeAdded(cUnmergedSubscriptions, 1)
1289 mainCtrl.SetTimesCounterWillBeAdded(cSubDelReqFromXapp, 2)
1290 mainCtrl.SetTimesCounterWillBeAdded(cSubDelReqToE2, 1)
1291 mainCtrl.SetTimesCounterWillBeAdded(cSubDelRespFromE2, 1)
1292 mainCtrl.SetTimesCounterWillBeAdded(cSubDelRespToXapp, 2)
1293 mainCtrl.GetCounterValuesBefore(t)
1296 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1298 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1299 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1300 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1301 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1304 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1306 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1307 //crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1308 //e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1309 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1311 resp, _ := xapp.Subscription.QuerySubscriptions()
1312 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1313 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1314 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560", "localhost:13660"})
1317 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1318 //e2termConn1.RecvSubsDelReq(t)
1319 //e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1320 xappConn1.RecvSubsDelResp(t, deltrans1)
1321 //Wait that subs is cleaned
1322 //mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1325 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1326 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1327 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1328 xappConn2.RecvSubsDelResp(t, deltrans2)
1329 //Wait that subs is cleaned
1330 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1332 xappConn1.TestMsgChanEmpty(t)
1333 xappConn2.TestMsgChanEmpty(t)
1334 e2termConn1.TestMsgChanEmpty(t)
1335 mainCtrl.wait_registry_empty(t, 10)
1337 mainCtrl.VerifyCounterValues(t)
1340 //-----------------------------------------------------------------------------
1341 // TestSubReqAndSubDelOkSameActionParallel
1344 // +-------+ +-------+ +---------+ +---------+
1345 // | xapp2 | | xapp1 | | submgr | | e2term |
1346 // +-------+ +-------+ +---------+ +---------+
1351 // | |------------->| |
1354 // | | |------------->|
1356 // |--------------------------->| |
1358 // | | |<-------------|
1360 // | |<-------------| |
1363 // |<---------------------------| |
1365 // | | SubDelReq 1 | |
1366 // | |------------->| |
1368 // | | SubDelResp 1 | |
1369 // | |<-------------| |
1371 // | SubDelReq 2 | |
1372 // |--------------------------->| |
1374 // | | | SubDelReq 2 |
1375 // | | |------------->|
1377 // | | | SubDelReq 2 |
1378 // | | |------------->|
1380 // | SubDelResp 2 | |
1381 // |<---------------------------| |
1383 //-----------------------------------------------------------------------------
1384 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1385 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1388 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1390 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1391 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1394 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1396 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1399 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1400 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1403 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1406 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1407 xappConn1.RecvSubsDelResp(t, deltrans1)
1410 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1411 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1412 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1413 xappConn2.RecvSubsDelResp(t, deltrans2)
1415 //Wait that subs is cleaned
1416 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1418 xappConn1.TestMsgChanEmpty(t)
1419 xappConn2.TestMsgChanEmpty(t)
1420 e2termConn1.TestMsgChanEmpty(t)
1421 mainCtrl.wait_registry_empty(t, 10)
1424 //-----------------------------------------------------------------------------
1425 // TestSubReqAndSubDelNokSameActionParallel
1428 // +-------+ +-------+ +---------+ +---------+
1429 // | xapp2 | | xapp1 | | submgr | | e2term |
1430 // +-------+ +-------+ +---------+ +---------+
1435 // | |------------->| |
1438 // | | |------------->|
1440 // |--------------------------->| |
1442 // | | |<-------------|
1444 // | | | SubDelReq |
1445 // | | |------------->|
1446 // | | | SubDelResp |
1447 // | | |<-------------|
1450 // | |<-------------| |
1453 // |<---------------------------| |
1455 //-----------------------------------------------------------------------------
1456 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1457 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1460 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1462 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1464 // E2t: Receive SubsReq (first)
1465 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1468 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1470 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1471 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1472 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1474 // E2t: send SubsFail (first)
1475 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1476 fparams1.Set(crereq1)
1477 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1479 // E2t: internal delete
1480 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1481 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1484 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1486 xappConn2.RecvSubsFail(t, cretrans2)
1488 //Wait that subs is cleaned
1489 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1491 xappConn1.TestMsgChanEmpty(t)
1492 xappConn2.TestMsgChanEmpty(t)
1493 e2termConn1.TestMsgChanEmpty(t)
1494 mainCtrl.wait_registry_empty(t, 10)
1497 //-----------------------------------------------------------------------------
1498 // TestSubReqAndSubDelNoAnswerSameActionParallel
1501 // +-------+ +-------+ +---------+ +---------+
1502 // | xapp2 | | xapp1 | | submgr | | e2term |
1503 // +-------+ +-------+ +---------+ +---------+
1508 // | |------------->| |
1511 // | | |------------->|
1513 // |--------------------------->| |
1516 // | | |------------->|
1519 // | | | SubDelReq |
1520 // | | |------------->|
1522 // | | | SubDelResp |
1523 // | | |<-------------|
1525 //-----------------------------------------------------------------------------
1526 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1527 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1530 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1532 xappConn1.SendSubsReq(t, rparams1, nil)
1534 crereq1, _ := e2termConn1.RecvSubsReq(t)
1537 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1539 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1540 xappConn2.SendSubsReq(t, rparams2, nil)
1541 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1543 //Req1 (retransmitted)
1544 e2termConn1.RecvSubsReq(t)
1546 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1547 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1549 //Wait that subs is cleaned
1550 mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10)
1552 xappConn1.TestMsgChanEmpty(t)
1553 xappConn2.TestMsgChanEmpty(t)
1554 e2termConn1.TestMsgChanEmpty(t)
1555 mainCtrl.wait_registry_empty(t, 15)
1558 //----------------------------- Policy cases ---------------------------------
1559 //-----------------------------------------------------------------------------
1560 // TestSubReqPolicyAndSubDelOk
1563 // +-------+ +---------+ +---------+
1564 // | xapp | | submgr | | e2term |
1565 // +-------+ +---------+ +---------+
1568 // |------------->| |
1571 // | |------------->|
1574 // | |<-------------|
1577 // |<-------------| |
1581 // |------------->| |
1584 // | |------------->|
1587 // | |<-------------|
1590 // |<-------------| |
1592 //-----------------------------------------------------------------------------
1593 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
1594 CaseBegin("TestSubReqAndSubDelOk")
1596 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1598 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1599 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1601 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1602 e2termConn1.SendSubsResp(t, crereq, cremsg)
1603 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1604 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1605 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1607 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1608 xappConn1.RecvSubsDelResp(t, deltrans)
1610 //Wait that subs is cleaned
1611 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1613 xappConn1.TestMsgChanEmpty(t)
1614 xappConn2.TestMsgChanEmpty(t)
1615 e2termConn1.TestMsgChanEmpty(t)
1616 mainCtrl.wait_registry_empty(t, 10)
1619 //-----------------------------------------------------------------------------
1620 // TestSubReqPolicyChangeAndSubDelOk
1623 // +-------+ +---------+ +---------+
1624 // | xapp | | submgr | | e2term |
1625 // +-------+ +---------+ +---------+
1628 // |------------->| |
1631 // | |------------->|
1634 // | |<-------------|
1637 // |<-------------| |
1640 // |------------->| |
1643 // | |------------->|
1646 // | |<-------------|
1649 // |<-------------| |
1652 // |------------->| |
1655 // | |------------->|
1658 // | |<-------------|
1661 // |<-------------| |
1663 //-----------------------------------------------------------------------------
1665 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
1666 CaseBegin("TestSubReqAndSubDelOk")
1668 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1670 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1671 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1673 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1674 e2termConn1.SendSubsResp(t, crereq, cremsg)
1675 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1678 rparams1.Req.RequestId.InstanceId = e2SubsId
1679 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
1680 xappConn1.SendSubsReq(t, rparams1, cretrans)
1682 crereq, cremsg = e2termConn1.RecvSubsReq(t)
1683 e2termConn1.SendSubsResp(t, crereq, cremsg)
1684 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1685 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1686 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 // TestSubReqAndSubDelOkTwoE2termParallel
1704 // +-------+ +---------+ +---------+ +---------+
1705 // | xapp | | submgr | | e2term1 | | e2term2 |
1706 // +-------+ +---------+ +---------+ +---------+
1711 // |------------->| | |
1714 // | |------------->| |
1717 // |------------->| | |
1720 // | |---------------------------->|
1723 // | |<-------------| |
1725 // |<-------------| | |
1727 // | |<----------------------------|
1729 // |<-------------| | |
1731 // | [SUBS 1 DELETE] | |
1733 // | [SUBS 2 DELETE] | |
1736 //-----------------------------------------------------------------------------
1737 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
1738 CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
1741 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1742 xappConn1.SendSubsReq(t, nil, cretrans1)
1743 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1745 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
1746 xappConn1.SendSubsReq(t, nil, cretrans2)
1747 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
1750 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1751 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1754 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
1755 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1758 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1759 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1760 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1761 xappConn1.RecvSubsDelResp(t, deltrans1)
1762 //Wait that subs is cleaned
1763 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1766 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
1767 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
1768 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
1769 xappConn1.RecvSubsDelResp(t, deltrans2)
1770 //Wait that subs is cleaned
1771 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1773 xappConn1.TestMsgChanEmpty(t)
1774 xappConn2.TestMsgChanEmpty(t)
1775 e2termConn1.TestMsgChanEmpty(t)
1776 e2termConn2.TestMsgChanEmpty(t)
1777 mainCtrl.wait_registry_empty(t, 10)
1780 //-----------------------------------------------------------------------------
1781 // TestSubReqInsertAndSubDelOk
1784 // +-------+ +---------+ +---------+
1785 // | xapp | | submgr | | e2term |
1786 // +-------+ +---------+ +---------+
1789 // |------------->| |
1792 // | |------------->|
1795 // | |<-------------|
1798 // |<-------------| |
1802 // |------------->| |
1805 // | |------------->|
1808 // | |<-------------|
1811 // |<-------------| |
1813 //-----------------------------------------------------------------------------
1814 func TestSubReqInsertAndSubDelOk(t *testing.T) {
1815 CaseBegin("TestInsertSubReqAndSubDelOk")
1817 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1819 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeInsert
1820 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1822 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1823 e2termConn1.SendSubsResp(t, crereq, cremsg)
1824 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1825 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1826 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1828 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1829 xappConn1.RecvSubsDelResp(t, deltrans)
1831 //Wait that subs is cleaned
1832 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1834 xappConn1.TestMsgChanEmpty(t)
1835 xappConn2.TestMsgChanEmpty(t)
1836 e2termConn1.TestMsgChanEmpty(t)
1837 mainCtrl.wait_registry_empty(t, 10)
1840 //-----------------------------------------------------------------------------
1841 // TestSubReqRetransmissionWithSameSubIdDiffXid
1843 // This case simulates case where xApp restarts and starts sending same
1844 // subscription requests which have already subscribed successfully
1847 // +-------+ +---------+ +---------+
1848 // | xapp | | submgr | | e2term |
1849 // +-------+ +---------+ +---------+
1852 // |------------->| |
1855 // | |------------->|
1858 // | |<-------------|
1861 // |<-------------| |
1863 // | xApp restart | |
1866 // | (retrans with same xApp generated subid but diff xid)
1867 // |------------->| |
1870 // |<-------------| |
1872 // | [SUBS DELETE] |
1875 //-----------------------------------------------------------------------------
1876 func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) {
1877 CaseBegin("TestSubReqRetransmissionWithSameSubIdDiffXid")
1880 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1881 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1882 e2termConn1.SendSubsResp(t, crereq, cremsg)
1883 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1885 // xApp restart here
1886 // --> artificial delay
1887 <-time.After(1 * time.Second)
1890 cretrans = xappConn1.SendSubsReq(t, nil, nil) //Retransmitted SubReq
1891 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1894 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1895 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1896 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1897 xappConn1.RecvSubsDelResp(t, deltrans)
1899 //Wait that subs is cleaned
1900 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1902 xappConn1.TestMsgChanEmpty(t)
1903 xappConn2.TestMsgChanEmpty(t)
1904 e2termConn1.TestMsgChanEmpty(t)
1905 mainCtrl.wait_registry_empty(t, 10)
1908 //-----------------------------------------------------------------------------
1909 // TestSubReqNokAndSubDelOkWithRestartInMiddle
1912 // +-------+ +---------+ +---------+
1913 // | xapp | | submgr | | e2term |
1914 // +-------+ +---------+ +---------+
1917 // |------------->| |
1920 // | |------------->|
1925 // | Submgr restart |
1929 // | |------------->|
1932 // | |<-------------|
1935 //-----------------------------------------------------------------------------
1937 func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
1938 CaseBegin("TestSubReqNokAndSubDelOkWithRestartInMiddle")
1940 // Remove possible existing subscrition
1941 mainCtrl.removeExistingSubscriptions(t)
1943 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
1944 xappConn1.SendSubsReq(t, nil, nil)
1945 e2termConn1.RecvSubsReq(t)
1946 mainCtrl.SetResetTestFlag(t, false)
1948 resp, _ := xapp.Subscription.QuerySubscriptions()
1949 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1950 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560"})
1951 e2SubsId := uint32(resp[0].SubscriptionID)
1952 t.Logf("e2SubsId = %v", e2SubsId)
1954 mainCtrl.SimulateRestart(t) // This will trigger sending of SubDelReq
1956 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1957 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1959 // Wait that subs is cleaned
1960 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1962 xappConn1.TestMsgChanEmpty(t)
1963 xappConn2.TestMsgChanEmpty(t)
1964 e2termConn1.TestMsgChanEmpty(t)
1965 mainCtrl.wait_registry_empty(t, 10)
1968 //-----------------------------------------------------------------------------
1969 // TestSubReqAndSubDelOkWithRestartInMiddle
1972 // +-------+ +---------+ +---------+
1973 // | xapp | | submgr | | e2term |
1974 // +-------+ +---------+ +---------+
1977 // |------------->| |
1980 // | |------------->|
1983 // | |<-------------|
1986 // |<-------------| |
1989 // | Submgr restart |
1992 // |------------->| |
1995 // | |------------->|
1998 // | |<-------------|
2001 // |<-------------| |
2003 //-----------------------------------------------------------------------------
2005 func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
2006 CaseBegin("TestSubReqAndSubDelOkWithRestartInMiddle")
2008 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2009 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2010 e2termConn1.SendSubsResp(t, crereq, cremsg)
2011 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2013 // Check subscription
2014 resp, _ := xapp.Subscription.QuerySubscriptions()
2015 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2016 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2017 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560"})
2019 mainCtrl.SimulateRestart(t)
2021 // Check that subscription is restored correctly after restart
2022 resp, _ = xapp.Subscription.QuerySubscriptions()
2023 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2024 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2025 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560"})
2027 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2028 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2029 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2030 xappConn1.RecvSubsDelResp(t, deltrans)
2032 //Wait that subs is cleaned
2033 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2035 xappConn1.TestMsgChanEmpty(t)
2036 xappConn2.TestMsgChanEmpty(t)
2037 e2termConn1.TestMsgChanEmpty(t)
2038 mainCtrl.wait_registry_empty(t, 10)
2041 //-----------------------------------------------------------------------------
2042 // TestSubReqAndSubDelOkSameActionWithRestartsInMiddle
2045 // +-------+ +-------+ +---------+ +---------+
2046 // | xapp2 | | xapp1 | | submgr | | e2term |
2047 // +-------+ +-------+ +---------+ +---------+
2052 // | |------------->| |
2055 // | | |------------->|
2057 // | | |<-------------|
2059 // | |<-------------| |
2062 // | submgr restart |
2067 // |--------------------------->| |
2070 // |<---------------------------| |
2072 // | | SubDelReq 1 | |
2073 // | |------------->| |
2075 // | | SubDelResp 1 | |
2076 // | |<-------------| |
2080 // | submgr restart |
2083 // | SubDelReq 2 | |
2084 // |--------------------------->| |
2086 // | | | SubDelReq 2 |
2087 // | | |------------->|
2089 // | | | SubDelReq 2 |
2090 // | | |------------->|
2092 // | SubDelResp 2 | |
2093 // |<---------------------------| |
2095 //-----------------------------------------------------------------------------
2097 func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
2098 CaseBegin("TestSubReqAndSubDelOkSameActionWithRestartsInMiddle")
2101 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2103 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2104 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2105 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2106 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2109 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2111 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2112 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
2114 // Check subscription
2115 resp, _ := xapp.Subscription.QuerySubscriptions() ////////////////////////////////
2116 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2117 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2118 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560", "localhost:13660"})
2120 mainCtrl.SimulateRestart(t)
2122 // Check that subscription is restored correctly after restart
2123 resp, _ = xapp.Subscription.QuerySubscriptions()
2124 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2125 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2126 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560", "localhost:13660"})
2129 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2130 xapp.Logger.Debug("xappConn1.RecvSubsDelResp")
2131 xappConn1.RecvSubsDelResp(t, deltrans1)
2132 xapp.Logger.Debug("xappConn1.RecvSubsDelResp received")
2134 mainCtrl.SimulateRestart(t)
2135 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2138 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
2139 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2141 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2142 xappConn2.RecvSubsDelResp(t, deltrans2)
2144 //Wait that subs is cleaned
2145 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2147 xappConn1.TestMsgChanEmpty(t)
2148 xappConn2.TestMsgChanEmpty(t)
2149 e2termConn1.TestMsgChanEmpty(t)
2150 mainCtrl.wait_registry_empty(t, 10)