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/e2ap/pkg/e2ap_wrapper"
28 "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststube2ap"
29 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
30 "github.com/stretchr/testify/assert"
33 func TestSuiteSetup(t *testing.T) {
34 // The effect of this call shall endure thgough the UT suite!
35 // If this causes any issues, the previout interface can be restored
37 // SetPackerIf(e2ap_wrapper.NewAsn1E2APPacker())
39 SetPackerIf(e2ap_wrapper.NewUtAsn1E2APPacker())
42 //-----------------------------------------------------------------------------
43 // TestRESTSubReqAndDeleteOkWithE2apUtWrapper
46 // +-------+ +---------+ +---------+ +---------+
47 // | xapp | | submgr | | e2term | | rtmgr |
48 // +-------+ +---------+ +---------+ +---------+
51 // |---------------->| | |
52 // | | RouteCreate | |
53 // | |--------------------------->| // The order of these events may vary
55 // | RESTSubResp | | | // The order of these events may vary
56 // |<----------------| | |
57 // | | RouteResponse| |
58 // | |<---------------------------| // The order of these events may vary
61 // | |------------->| | // The order of these events may vary
64 // | |<-------------| |
66 // |<----------------| | |
68 // | RESTSubDelReq | | |
69 // |---------------->| | |
71 // | |------------->| |
73 // | RESTSubDelResp| | |
74 // |<----------------| | |
77 // | |<-------------| |
81 //-----------------------------------------------------------------------------
82 func TestRESTSubReqAndDeleteOkWithE2apUtWrapper(t *testing.T) {
84 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
86 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
88 waitSubsCleanup(t, e2SubsId, 10)
91 //-----------------------------------------------------------------------------
92 // TestRESTSubReqAndE1apDeleteReqPackingError
95 // +-------+ +---------+ +---------+ +---------+
96 // | xapp | | submgr | | e2term | | rtmgr |
97 // +-------+ +---------+ +---------+ +---------+
100 // |---------------->| | |
101 // | | RouteCreate | |
102 // | |--------------------------->| // The order of these events may vary
104 // | RESTSubResp | | | // The order of these events may vary
105 // |<----------------| | |
106 // | | RouteResponse| |
107 // | |<---------------------------| // The order of these events may vary
110 // | |------------->| | // The order of these events may vary
113 // | |<-------------| |
114 // | RESTNotif1 | | |
115 // |<----------------| | |
117 // | RESTSubDelReq | | |
118 // |---------------->| | |
120 // | RESTSubDelResp| | |
121 // |<----------------| | |
125 //-----------------------------------------------------------------------------
126 func TestRESTSubReqAndE1apDeleteReqPackingError(t *testing.T) {
128 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
130 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, false)
131 xappConn1.SendRESTSubsDelReq(t, &restSubId)
132 defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, true)
134 waitSubsCleanup(t, e2SubsId, 10)
137 //-----------------------------------------------------------------------------
138 // TestRESTSubReqAndE1apDeleteRespUnpackingError
141 // +-------+ +---------+ +---------+ +---------+
142 // | xapp | | submgr | | e2term | | rtmgr |
143 // +-------+ +---------+ +---------+ +---------+
145 // | RESTSubReq | | |
146 // |---------------->| | |
147 // | | RouteCreate | |
148 // | |--------------------------->| // The order of these events may vary
150 // | RESTSubResp | | | // The order of these events may vary
151 // |<----------------| | |
152 // | | RouteResponse| |
153 // | |<---------------------------| // The order of these events may vary
156 // | |------------->| | // The order of these events may vary
159 // | |<-------------| |
160 // | RESTNotif1 | | |
161 // |<----------------| | |
163 // | RESTSubDelReq | | |
164 // |---------------->| | |
166 // | |------------->| |
168 // | RESTSubDelResp| | |
169 // |<----------------| | | // The order of these events may vary
171 // | | SubDelResp | |
172 // | |<-------------| | // 1.st NOK
175 // | |------------->| |
177 // | | SubDelResp | |
178 // | |<-------------| | // 2.nd NOK
180 //-----------------------------------------------------------------------------
182 func TestRESTSubReqAndE1apDeleteRespUnpackingError(t *testing.T) {
184 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
186 xappConn1.SendRESTSubsDelReq(t, &restSubId)
187 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, false)
188 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
189 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
191 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
192 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
194 defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, true)
196 waitSubsCleanup(t, e2SubsId, 10)
199 //-----------------------------------------------------------------------------
200 // TestSubReqAndRouteNok
203 // +-------+ +---------+ +---------+
204 // | xapp | | submgr | | rtmgr |
205 // +-------+ +---------+ +---------+
208 // |------------->| |
211 // | |------------->|
215 // | |<-------------|
217 // | [SUBS INT DELETE] |
220 //-----------------------------------------------------------------------------
222 func TestSubReqAndRouteNok(t *testing.T) {
223 CaseBegin("TestSubReqAndRouteNok")
225 // Init counter check
226 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
227 Counter{cSubReqFromXapp, 1},
228 Counter{cRouteCreateFail, 1},
231 waiter := rtmgrHttp.AllocNextEvent(false)
232 newSubsId := mainCtrl.get_registry_next_subid(t)
233 xappConn1.SendSubsReq(t, nil, nil)
236 //Wait that subs is cleaned
237 mainCtrl.wait_subs_clean(t, newSubsId, 10)
239 xappConn1.TestMsgChanEmpty(t)
240 xappConn2.TestMsgChanEmpty(t)
241 e2termConn1.TestMsgChanEmpty(t)
242 mainCtrl.wait_registry_empty(t, 10)
244 <-time.After(1 * time.Second)
245 mainCtrl.VerifyCounterValues(t)
248 //-----------------------------------------------------------------------------
249 // TestSubReqAndRouteUpdateNok
252 // +-------+ +-------+ +---------+ +---------+
253 // | xapp2 | | xapp1 | | submgr | | rtmgr |
254 // +-------+ +-------+ +---------+ +---------+
256 // | [SUBS CREATE] | |
260 // | SubReq (mergeable) | |
261 // |--------------------------->| | |
263 // | | | RouteUpdate |
264 // | | |------------->|
266 // | | | RouteUpdate |
267 // | | | status:400 |
268 // | | |<-------------|
270 // | [SUBS INT DELETE] | |
273 // | [SUBS DELETE] | |
276 func TestSubReqAndRouteUpdateNok(t *testing.T) {
277 CaseBegin("TestSubReqAndRouteUpdateNok")
279 // Init counter check
280 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
281 Counter{cSubReqFromXapp, 2},
282 Counter{cSubReqToE2, 1},
283 Counter{cSubRespFromE2, 1},
284 Counter{cSubRespToXapp, 1},
285 Counter{cRouteCreateUpdateFail, 1},
286 Counter{cSubDelReqFromXapp, 1},
287 Counter{cSubDelReqToE2, 1},
288 Counter{cSubDelRespFromE2, 1},
289 Counter{cSubDelRespToXapp, 1},
292 cretrans := xappConn1.SendSubsReq(t, nil, nil)
293 crereq, cremsg := e2termConn1.RecvSubsReq(t)
294 e2termConn1.SendSubsResp(t, crereq, cremsg)
295 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
297 resp, _ := xapp.Subscription.QuerySubscriptions()
298 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
299 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
300 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
302 waiter := rtmgrHttp.AllocNextEvent(false)
303 newSubsId := mainCtrl.get_registry_next_subid(t)
304 xappConn2.SendSubsReq(t, nil, nil)
307 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
308 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
310 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
311 xappConn1.RecvSubsDelResp(t, deltrans)
313 //Wait that subs is cleaned
314 mainCtrl.wait_subs_clean(t, newSubsId, 10)
315 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
317 xappConn1.TestMsgChanEmpty(t)
318 xappConn2.TestMsgChanEmpty(t)
319 e2termConn1.TestMsgChanEmpty(t)
320 mainCtrl.wait_registry_empty(t, 10)
322 mainCtrl.VerifyCounterValues(t)
325 //-----------------------------------------------------------------------------
326 // TestSubDelReqAndRouteDeleteNok
329 // +-------+ +---------+ +---------+ +---------+
330 // | xapp | | submgr | | e2term | | rtmgr |
331 // +-------+ +---------+ +---------+ +---------+
333 // | [SUBS CREATE] | |
338 // |------------->| | |
340 // | |------------->| |
342 // | |<-------------| |
344 // |<-------------| | |
345 // | | RouteDelete | |
346 // | |---------------------------->|
348 // | | RouteDelete | |
349 // | | status:400 | |
350 // | |<----------------------------|
352 func TestSubDelReqAndRouteDeleteNok(t *testing.T) {
353 CaseBegin("TestSubDelReqAndRouteDeleteNok")
355 // Init counter check
356 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
357 Counter{cSubReqFromXapp, 1},
358 Counter{cSubReqToE2, 1},
359 Counter{cSubRespFromE2, 1},
360 Counter{cSubRespToXapp, 1},
361 Counter{cSubDelReqFromXapp, 1},
362 Counter{cRouteDeleteFail, 1},
363 Counter{cSubDelReqToE2, 1},
364 Counter{cSubDelRespFromE2, 1},
365 Counter{cSubDelRespToXapp, 1},
368 cretrans := xappConn1.SendSubsReq(t, nil, nil)
369 crereq, cremsg := e2termConn1.RecvSubsReq(t)
370 e2termConn1.SendSubsResp(t, crereq, cremsg)
371 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
373 resp, _ := xapp.Subscription.QuerySubscriptions()
374 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
375 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
376 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
378 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
379 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
381 waiter := rtmgrHttp.AllocNextEvent(false)
382 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
385 xappConn1.RecvSubsDelResp(t, deltrans)
387 //Wait that subs is cleaned
388 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
390 xappConn1.TestMsgChanEmpty(t)
391 xappConn2.TestMsgChanEmpty(t)
392 e2termConn1.TestMsgChanEmpty(t)
393 mainCtrl.wait_registry_empty(t, 10)
395 mainCtrl.VerifyCounterValues(t)
398 //-----------------------------------------------------------------------------
399 // TestSubMergeDelAndRouteUpdateNok
401 // +-------+ +-------+ +---------+ +---------+
402 // | xapp2 | | xapp1 | | submgr | | e2term |
403 // +-------+ +-------+ +---------+ +---------+
408 // | |------------->| |
411 // | | |------------->|
413 // | | |<-------------|
415 // | |<-------------| |
418 // |--------------------------->| |
421 // |<---------------------------| |
423 // | | SubDelReq 1 | |
424 // | |------------->| |
425 // | | | RouteUpdate |
426 // | | |-----> rtmgr |
428 // | | | RouteUpdate |
429 // | | | status:400 |
430 // | | |<----- rtmgr |
432 // | | SubDelResp 1 | |
433 // | |<-------------| |
436 // |--------------------------->| |
438 // | | | SubDelReq 2 |
439 // | | |------------->|
441 // | | | SubDelReq 2 |
442 // | | |------------->|
444 // | SubDelResp 2 | |
445 // |<---------------------------| |
447 //-----------------------------------------------------------------------------
448 func TestSubMergeDelAndRouteUpdateNok(t *testing.T) {
449 CaseBegin("TestSubMergeDelAndRouteUpdateNok")
451 // Init counter check
452 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
453 Counter{cSubReqFromXapp, 2},
454 Counter{cSubReqToE2, 1},
455 Counter{cSubRespFromE2, 1},
456 Counter{cSubRespToXapp, 2},
457 Counter{cSubDelReqFromXapp, 2},
458 Counter{cRouteDeleteUpdateFail, 1},
459 Counter{cSubDelReqToE2, 1},
460 Counter{cSubDelRespFromE2, 1},
461 Counter{cSubDelRespToXapp, 2},
465 rparams1 := &teststube2ap.E2StubSubsReqParams{}
467 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
468 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
469 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
470 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
473 rparams2 := &teststube2ap.E2StubSubsReqParams{}
475 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
476 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
478 resp, _ := xapp.Subscription.QuerySubscriptions()
479 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
480 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
481 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
484 waiter := rtmgrHttp.AllocNextEvent(false)
485 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
488 xappConn1.RecvSubsDelResp(t, deltrans1)
491 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
492 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
493 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
494 xappConn2.RecvSubsDelResp(t, deltrans2)
495 //Wait that subs is cleaned
496 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
498 xappConn1.TestMsgChanEmpty(t)
499 xappConn2.TestMsgChanEmpty(t)
500 e2termConn1.TestMsgChanEmpty(t)
501 mainCtrl.wait_registry_empty(t, 10)
503 mainCtrl.VerifyCounterValues(t)
506 //-----------------------------------------------------------------------------
508 //-----------------------------------------------------------------------------
509 // TestSubReqAndSubDelOk
512 // +-------+ +---------+ +---------+
513 // | xapp | | submgr | | e2term |
514 // +-------+ +---------+ +---------+
517 // |------------->| |
520 // | |------------->|
523 // | |<-------------|
526 // |<-------------| |
530 // |------------->| |
533 // | |------------->|
536 // | |<-------------|
539 // |<-------------| |
541 //-----------------------------------------------------------------------------
542 func TestSubReqAndSubDelOk(t *testing.T) {
543 CaseBegin("TestSubReqAndSubDelOk")
545 // Init counter check
546 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
547 Counter{cSubReqFromXapp, 1},
548 Counter{cSubReqToE2, 1},
549 Counter{cSubRespFromE2, 1},
550 Counter{cSubRespToXapp, 1},
551 Counter{cSubDelReqFromXapp, 1},
552 Counter{cSubDelReqToE2, 1},
553 Counter{cSubDelRespFromE2, 1},
554 Counter{cSubDelRespToXapp, 1},
557 cretrans := xappConn1.SendSubsReq(t, nil, nil)
558 crereq, cremsg := e2termConn1.RecvSubsReq(t)
559 e2termConn1.SendSubsResp(t, crereq, cremsg)
560 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
562 resp, _ := xapp.Subscription.QuerySubscriptions()
563 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
564 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
565 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
567 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
568 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
570 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
571 xappConn1.RecvSubsDelResp(t, deltrans)
573 //Wait that subs is cleaned
574 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
576 xappConn1.TestMsgChanEmpty(t)
577 xappConn2.TestMsgChanEmpty(t)
578 e2termConn1.TestMsgChanEmpty(t)
579 mainCtrl.wait_registry_empty(t, 10)
581 mainCtrl.VerifyCounterValues(t)
584 //-----------------------------------------------------------------------------
585 // TestSubReqRetransmission
588 // +-------+ +---------+ +---------+
589 // | xapp | | submgr | | e2term |
590 // +-------+ +---------+ +---------+
593 // |------------->| |
596 // | |------------->|
600 // |------------->| |
603 // | |<-------------|
606 // |<-------------| |
611 //-----------------------------------------------------------------------------
612 func TestSubReqRetransmission(t *testing.T) {
613 CaseBegin("TestSubReqRetransmission")
616 cretrans := xappConn1.SendSubsReq(t, nil, nil)
617 crereq, cremsg := e2termConn1.RecvSubsReq(t)
619 seqBef := mainCtrl.get_msgcounter(t)
620 xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq
621 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
623 // hack as there is no real way to see has message be handled.
624 // Previuos counter check just tells that is has been received by submgr
625 // --> artificial delay
626 <-time.After(1 * time.Second)
627 e2termConn1.SendSubsResp(t, crereq, cremsg)
628 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
631 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
632 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
633 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
634 xappConn1.RecvSubsDelResp(t, deltrans)
636 //Wait that subs is cleaned
637 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
639 xappConn1.TestMsgChanEmpty(t)
640 xappConn2.TestMsgChanEmpty(t)
641 e2termConn1.TestMsgChanEmpty(t)
642 mainCtrl.wait_registry_empty(t, 10)
645 //-----------------------------------------------------------------------------
646 // TestSubDelReqRetransmission
649 // +-------+ +---------+ +---------+
650 // | xapp | | submgr | | e2term |
651 // +-------+ +---------+ +---------+
657 // |------------->| |
660 // | |------------->|
665 // |------------->| |
668 // | |<-------------|
671 // |<-------------| |
673 //-----------------------------------------------------------------------------
674 func TestSubDelReqRetransmission(t *testing.T) {
675 CaseBegin("TestSubDelReqRetransmission")
678 cretrans := xappConn1.SendSubsReq(t, nil, nil)
679 crereq, cremsg := e2termConn1.RecvSubsReq(t)
680 e2termConn1.SendSubsResp(t, crereq, cremsg)
681 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
684 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
685 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
687 seqBef := mainCtrl.get_msgcounter(t)
688 xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq
689 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
691 // hack as there is no real way to see has message be handled.
692 // Previuos counter check just tells that is has been received by submgr
693 // --> artificial delay
694 <-time.After(1 * time.Second)
696 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
697 xappConn1.RecvSubsDelResp(t, deltrans)
699 //Wait that subs is cleaned
700 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
702 xappConn1.TestMsgChanEmpty(t)
703 xappConn2.TestMsgChanEmpty(t)
704 e2termConn1.TestMsgChanEmpty(t)
705 mainCtrl.wait_registry_empty(t, 10)
708 //-----------------------------------------------------------------------------
709 // TestSubDelReqCollision
712 // +-------+ +---------+ +---------+
713 // | xapp | | submgr | | e2term |
714 // +-------+ +---------+ +---------+
720 // |------------->| |
723 // | |------------->|
728 // |------------->| |
730 // | | SubDelResp 1 |
731 // | |<-------------|
733 // | SubDelResp 1 | |
734 // |<-------------| |
736 // | SubDelResp 2 | |
737 // |<-------------| |
739 //-----------------------------------------------------------------------------
741 func TestSubDelReqCollision(t *testing.T) {
742 CaseBegin("TestSubDelReqCollision")
745 cretrans := xappConn1.SendSubsReq(t, nil, nil)
746 crereq, cremsg := e2termConn1.RecvSubsReq(t)
747 e2termConn1.SendSubsResp(t, crereq, cremsg)
748 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
751 xappConn1.SendSubsDelReq(t, nil, e2SubsId)
752 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
754 // Subs Delete colliding
755 seqBef := mainCtrl.get_msgcounter(t)
756 deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
757 xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq
758 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
760 // hack as there is no real way to see has message be handled.
761 // Previuos counter check just tells that is has been received by submgr
762 // --> artificial delay
763 <-time.After(1 * time.Second)
765 // Del resp for first and second
766 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
768 // don't care in which order responses are received
769 xappConn1.RecvSubsDelResp(t, nil)
770 xappConn1.RecvSubsDelResp(t, nil)
772 //Wait that subs is cleaned
773 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
775 xappConn1.TestMsgChanEmpty(t)
776 xappConn2.TestMsgChanEmpty(t)
777 e2termConn1.TestMsgChanEmpty(t)
778 mainCtrl.wait_registry_empty(t, 10)
781 //-----------------------------------------------------------------------------
782 // TestSubReqAndSubDelOkTwoParallel
785 // +-------+ +-------+ +---------+ +---------+
786 // | xapp | | xapp | | submgr | | e2term |
787 // +-------+ +-------+ +---------+ +---------+
792 // | |------------->| |
795 // | | |------------->|
798 // |------------------------>| |
801 // | | |------------->|
804 // | | |<-------------|
806 // | |<-------------| |
809 // | | |<-------------|
811 // |<------------------------| |
813 // | | [SUBS 1 DELETE] |
815 // | | [SUBS 2 DELETE] |
818 //-----------------------------------------------------------------------------
820 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
821 CaseBegin("TestSubReqAndSubDelOkTwoParallel")
824 rparams1 := &teststube2ap.E2StubSubsReqParams{}
826 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
827 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
830 rparams2 := &teststube2ap.E2StubSubsReqParams{}
833 rparams2.Req.EventTriggerDefinition.Data.Length = 1
834 rparams2.Req.EventTriggerDefinition.Data.Data = make([]uint8, rparams2.Req.EventTriggerDefinition.Data.Length)
835 rparams2.Req.EventTriggerDefinition.Data.Data[0] = 2
837 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
838 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
841 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
842 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
845 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
846 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
849 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
850 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
851 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
852 xappConn1.RecvSubsDelResp(t, deltrans1)
853 //Wait that subs is cleaned
854 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
857 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
858 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
859 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
860 xappConn2.RecvSubsDelResp(t, deltrans2)
861 //Wait that subs is cleaned
862 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
864 xappConn1.TestMsgChanEmpty(t)
865 xappConn2.TestMsgChanEmpty(t)
866 e2termConn1.TestMsgChanEmpty(t)
867 mainCtrl.wait_registry_empty(t, 10)
870 //-----------------------------------------------------------------------------
871 // TestSameSubsDiffRan
872 // Same subscription to different RANs
875 // +-------+ +---------+ +---------+
876 // | xapp | | submgr | | e2term |
877 // +-------+ +---------+ +---------+
882 // |------------->| |
885 // | |------------->|
888 // | |<-------------|
891 // |<-------------| |
894 // |------------->| |
897 // | |------------->|
900 // | |<-------------|
903 // |<-------------| |
905 // | [SUBS r1 DELETE] |
907 // | [SUBS r2 DELETE] |
910 //-----------------------------------------------------------------------------
911 func TestSameSubsDiffRan(t *testing.T) {
912 CaseBegin("TestSameSubsDiffRan")
915 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
916 xappConn1.SendSubsReq(t, nil, cretrans1)
917 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
918 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
919 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
922 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
923 xappConn1.SendSubsReq(t, nil, cretrans2)
924 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
925 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
926 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
929 deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
930 xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
931 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
932 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
933 xappConn1.RecvSubsDelResp(t, deltrans1)
934 //Wait that subs is cleaned
935 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
938 deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
939 xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
940 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
941 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
942 xappConn1.RecvSubsDelResp(t, deltrans2)
943 //Wait that subs is cleaned
944 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
946 xappConn1.TestMsgChanEmpty(t)
947 xappConn2.TestMsgChanEmpty(t)
948 e2termConn1.TestMsgChanEmpty(t)
949 mainCtrl.wait_registry_empty(t, 10)
952 //-----------------------------------------------------------------------------
953 // TestSubReqRetryInSubmgr
956 // +-------+ +---------+ +---------+
957 // | xapp | | submgr | | e2term |
958 // +-------+ +---------+ +---------+
961 // |------------->| |
964 // | |------------->|
968 // | |------------->|
971 // | |<-------------|
974 // |<-------------| |
979 //-----------------------------------------------------------------------------
981 func TestSubReqRetryInSubmgr(t *testing.T) {
982 CaseBegin("TestSubReqRetryInSubmgr start")
984 // Init counter check
985 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
986 Counter{cSubReqFromXapp, 1},
987 Counter{cSubReqToE2, 1},
988 Counter{cSubReReqToE2, 1},
989 Counter{cSubRespFromE2, 1},
990 Counter{cSubRespToXapp, 1},
991 Counter{cSubDelReqFromXapp, 1},
992 Counter{cSubDelReqToE2, 1},
993 Counter{cSubDelRespFromE2, 1},
994 Counter{cSubDelRespToXapp, 1},
997 // Xapp: Send SubsReq
998 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1000 // E2t: Receive 1st SubsReq
1001 e2termConn1.RecvSubsReq(t)
1003 // E2t: Receive 2nd SubsReq and send SubsResp
1004 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1005 e2termConn1.SendSubsResp(t, crereq, cremsg)
1007 // Xapp: Receive SubsResp
1008 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1010 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1011 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1012 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1013 xappConn1.RecvSubsDelResp(t, deltrans)
1015 // Wait that subs is cleaned
1016 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1018 xappConn1.TestMsgChanEmpty(t)
1019 xappConn2.TestMsgChanEmpty(t)
1020 e2termConn1.TestMsgChanEmpty(t)
1021 mainCtrl.wait_registry_empty(t, 10)
1023 mainCtrl.VerifyCounterValues(t)
1026 //-----------------------------------------------------------------------------
1027 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
1030 // +-------+ +---------+ +---------+
1031 // | xapp | | submgr | | e2term |
1032 // +-------+ +---------+ +---------+
1035 // |------------->| |
1038 // | |------------->|
1042 // | |------------->|
1045 // | |------------->|
1048 // | |<-------------|
1051 //-----------------------------------------------------------------------------
1052 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
1053 CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
1055 // Init counter check
1056 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1057 Counter{cSubReqFromXapp, 1},
1058 Counter{cSubReqToE2, 1},
1059 Counter{cSubReReqToE2, 1},
1060 Counter{cSubReqTimerExpiry, 2},
1061 Counter{cSubDelReqToE2, 1},
1062 Counter{cSubDelRespFromE2, 1},
1065 // Xapp: Send SubsReq
1066 xappConn1.SendSubsReq(t, nil, nil)
1068 // E2t: Receive 1st SubsReq
1069 e2termConn1.RecvSubsReq(t)
1071 // E2t: Receive 2nd SubsReq
1072 e2termConn1.RecvSubsReq(t)
1074 // E2t: Send receive SubsDelReq and send SubsResp
1075 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1076 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1078 // Wait that subs is cleaned
1079 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 10)
1081 xappConn1.TestMsgChanEmpty(t)
1082 xappConn2.TestMsgChanEmpty(t)
1083 e2termConn1.TestMsgChanEmpty(t)
1084 mainCtrl.wait_registry_empty(t, 10)
1086 mainCtrl.VerifyCounterValues(t)
1089 //-----------------------------------------------------------------------------
1090 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
1093 // +-------+ +---------+ +---------+
1094 // | xapp | | submgr | | e2term |
1095 // +-------+ +---------+ +---------+
1098 // |------------->| |
1101 // | |------------->|
1105 // | |------------->|
1108 // | |------------->|
1112 // | |------------->|
1116 //-----------------------------------------------------------------------------
1118 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
1119 CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
1121 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1122 Counter{cSubReqFromXapp, 1},
1123 Counter{cSubReqToE2, 1},
1124 Counter{cSubReReqToE2, 1},
1125 Counter{cSubReqTimerExpiry, 2},
1126 Counter{cSubDelReqToE2, 1},
1127 Counter{cSubDelReReqToE2, 1},
1128 Counter{cSubDelReqTimerExpiry, 2},
1131 // Xapp: Send SubsReq
1132 xappConn1.SendSubsReq(t, nil, nil)
1134 // E2t: Receive 1st SubsReq
1135 e2termConn1.RecvSubsReq(t)
1137 // E2t: Receive 2nd SubsReq
1138 e2termConn1.RecvSubsReq(t)
1140 // E2t: Receive 1st SubsDelReq
1141 e2termConn1.RecvSubsDelReq(t)
1143 // E2t: Receive 2nd SubsDelReq
1144 delreq, _ := e2termConn1.RecvSubsDelReq(t)
1146 // Wait that subs is cleaned
1147 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 15)
1149 xappConn1.TestMsgChanEmpty(t)
1150 xappConn2.TestMsgChanEmpty(t)
1151 e2termConn1.TestMsgChanEmpty(t)
1152 mainCtrl.wait_registry_empty(t, 10)
1154 mainCtrl.VerifyCounterValues(t)
1157 //-----------------------------------------------------------------------------
1158 // TestSubReqSubFailRespInSubmgr
1161 // +-------+ +---------+ +---------+
1162 // | xapp | | submgr | | e2term |
1163 // +-------+ +---------+ +---------+
1166 // |------------->| |
1169 // | |------------->|
1172 // | |<-------------|
1175 // | |------------->|
1178 // | |<-------------|
1181 // |<-------------| |
1184 //-----------------------------------------------------------------------------
1186 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1187 CaseBegin("TestSubReqSubFailRespInSubmgr start")
1189 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1190 Counter{cSubReqFromXapp, 1},
1191 Counter{cSubReqToE2, 1},
1192 Counter{cSubFailFromE2, 1},
1193 Counter{cSubFailToXapp, 1},
1196 // Xapp: Send SubsReq
1197 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1199 // E2t: Receive SubsReq and send SubsFail (first)
1200 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1201 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1202 fparams1.Set(crereq1)
1203 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1205 // E2t: Receive SubsDelReq and send SubsDelResp (internal first)
1206 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1207 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1209 // Xapp: Receive SubsFail
1210 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
1212 // Wait that subs is cleaned
1213 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1215 xappConn1.TestMsgChanEmpty(t)
1216 xappConn2.TestMsgChanEmpty(t)
1217 e2termConn1.TestMsgChanEmpty(t)
1218 mainCtrl.wait_registry_empty(t, 10)
1220 mainCtrl.VerifyCounterValues(t)
1223 //-----------------------------------------------------------------------------
1224 // TestSubDelReqRetryInSubmgr
1227 // +-------+ +---------+ +---------+
1228 // | xapp | | submgr | | e2term |
1229 // +-------+ +---------+ +---------+
1231 // | [SUBS CREATE] |
1235 // |------------->| |
1238 // | |------------->|
1241 // | |------------->|
1244 // | |<-------------|
1247 // |<-------------| |
1249 //-----------------------------------------------------------------------------
1251 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1253 CaseBegin("TestSubDelReqRetryInSubmgr start")
1256 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1257 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1258 e2termConn1.SendSubsResp(t, crereq, cremsg)
1259 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1262 // Xapp: Send SubsDelReq
1263 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1265 // E2t: Receive 1st SubsDelReq
1266 e2termConn1.RecvSubsDelReq(t)
1268 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1269 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1270 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1272 // Xapp: Receive SubsDelResp
1273 xappConn1.RecvSubsDelResp(t, deltrans)
1275 // Wait that subs is cleaned
1276 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1278 xappConn1.TestMsgChanEmpty(t)
1279 xappConn2.TestMsgChanEmpty(t)
1280 e2termConn1.TestMsgChanEmpty(t)
1281 mainCtrl.wait_registry_empty(t, 10)
1284 //-----------------------------------------------------------------------------
1285 // TestSubDelReqTwoRetriesNoRespInSubmgr
1288 // +-------+ +---------+ +---------+
1289 // | xapp | | submgr | | e2term |
1290 // +-------+ +---------+ +---------+
1292 // | [SUBS CREATE] |
1296 // |------------->| |
1299 // | |------------->|
1302 // | |------------->|
1306 // |<-------------| |
1308 //-----------------------------------------------------------------------------
1310 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1312 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
1315 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1316 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1317 e2termConn1.SendSubsResp(t, crereq, cremsg)
1318 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1321 // Xapp: Send SubsDelReq
1322 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1324 // E2t: Receive 1st SubsDelReq
1325 e2termConn1.RecvSubsDelReq(t)
1327 // E2t: Receive 2nd SubsDelReq
1328 e2termConn1.RecvSubsDelReq(t)
1330 // Xapp: Receive SubsDelResp
1331 xappConn1.RecvSubsDelResp(t, deltrans)
1333 // Wait that subs is cleaned
1334 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1336 xappConn1.TestMsgChanEmpty(t)
1337 xappConn2.TestMsgChanEmpty(t)
1338 e2termConn1.TestMsgChanEmpty(t)
1339 mainCtrl.wait_registry_empty(t, 10)
1342 //-----------------------------------------------------------------------------
1343 // TestSubDelReqSubDelFailRespInSubmgr
1346 // +-------+ +---------+ +---------+
1347 // | xapp | | submgr | | e2term |
1348 // +-------+ +---------+ +---------+
1350 // | [SUBS CREATE] |
1354 // |------------->| |
1357 // | |------------->|
1360 // | |<-------------|
1363 // |<-------------| |
1366 //-----------------------------------------------------------------------------
1368 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1369 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1371 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1372 Counter{cSubReqFromXapp, 1},
1373 Counter{cSubReqToE2, 1},
1374 Counter{cSubRespFromE2, 1},
1375 Counter{cSubRespToXapp, 1},
1376 Counter{cSubDelReqFromXapp, 1},
1377 Counter{cSubDelReqToE2, 1},
1378 Counter{cSubDelFailFromE2, 1},
1379 Counter{cSubDelRespToXapp, 1},
1383 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1384 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1385 e2termConn1.SendSubsResp(t, crereq, cremsg)
1386 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1388 // Xapp: Send SubsDelReq
1389 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1391 // E2t: Send receive SubsDelReq and send SubsDelFail
1392 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1393 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1395 // Xapp: Receive SubsDelResp
1396 xappConn1.RecvSubsDelResp(t, deltrans)
1398 // Wait that subs is cleaned
1399 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1401 xappConn1.TestMsgChanEmpty(t)
1402 xappConn2.TestMsgChanEmpty(t)
1403 e2termConn1.TestMsgChanEmpty(t)
1404 mainCtrl.wait_registry_empty(t, 10)
1406 mainCtrl.VerifyCounterValues(t)
1409 //-----------------------------------------------------------------------------
1410 // TestSubReqAndSubDelOkSameAction
1413 // +-------+ +-------+ +---------+ +---------+
1414 // | xapp2 | | xapp1 | | submgr | | e2term |
1415 // +-------+ +-------+ +---------+ +---------+
1420 // | |------------->| |
1423 // | | |------------->|
1425 // | | |<-------------|
1427 // | |<-------------| |
1430 // |--------------------------->| |
1433 // |<---------------------------| |
1435 // | | SubDelReq 1 | |
1436 // | |------------->| |
1438 // | | SubDelResp 1 | |
1439 // | |<-------------| |
1441 // | SubDelReq 2 | |
1442 // |--------------------------->| |
1444 // | | | SubDelReq 2 |
1445 // | | |------------->|
1447 // | | | SubDelReq 2 |
1448 // | | |------------->|
1450 // | SubDelResp 2 | |
1451 // |<---------------------------| |
1453 //-----------------------------------------------------------------------------
1454 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
1455 CaseBegin("TestSubReqAndSubDelOkSameAction")
1457 // Init counter check
1458 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1459 Counter{cSubReqFromXapp, 2},
1460 Counter{cSubReqToE2, 1},
1461 Counter{cSubRespFromE2, 1},
1462 Counter{cSubRespToXapp, 2},
1463 Counter{cMergedSubscriptions, 1},
1464 Counter{cUnmergedSubscriptions, 1},
1465 Counter{cSubDelReqFromXapp, 2},
1466 Counter{cSubDelReqToE2, 1},
1467 Counter{cSubDelRespFromE2, 1},
1468 Counter{cSubDelRespToXapp, 2},
1472 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1474 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1475 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1476 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1477 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1480 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1482 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1483 //crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1484 //e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1485 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1487 resp, _ := xapp.Subscription.QuerySubscriptions()
1488 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1489 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1490 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
1493 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1494 //e2termConn1.RecvSubsDelReq(t)
1495 //e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1496 xappConn1.RecvSubsDelResp(t, deltrans1)
1497 //Wait that subs is cleaned
1498 //mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1501 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1502 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1503 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1504 xappConn2.RecvSubsDelResp(t, deltrans2)
1505 //Wait that subs is cleaned
1506 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1508 xappConn1.TestMsgChanEmpty(t)
1509 xappConn2.TestMsgChanEmpty(t)
1510 e2termConn1.TestMsgChanEmpty(t)
1511 mainCtrl.wait_registry_empty(t, 10)
1513 mainCtrl.VerifyCounterValues(t)
1516 //-----------------------------------------------------------------------------
1517 // TestSubReqAndSubDelOkSameActionParallel
1520 // +-------+ +-------+ +---------+ +---------+
1521 // | xapp2 | | xapp1 | | submgr | | e2term |
1522 // +-------+ +-------+ +---------+ +---------+
1527 // | |------------->| |
1530 // | | |------------->|
1532 // |--------------------------->| |
1534 // | | |<-------------|
1536 // | |<-------------| |
1539 // |<---------------------------| |
1541 // | | SubDelReq 1 | |
1542 // | |------------->| |
1544 // | | SubDelResp 1 | |
1545 // | |<-------------| |
1547 // | SubDelReq 2 | |
1548 // |--------------------------->| |
1550 // | | | SubDelReq 2 |
1551 // | | |------------->|
1553 // | | | SubDelReq 2 |
1554 // | | |------------->|
1556 // | SubDelResp 2 | |
1557 // |<---------------------------| |
1559 //-----------------------------------------------------------------------------
1560 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1561 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1564 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1566 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1567 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1570 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1572 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1575 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1576 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1579 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1582 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1583 xappConn1.RecvSubsDelResp(t, deltrans1)
1586 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1587 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1588 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1589 xappConn2.RecvSubsDelResp(t, deltrans2)
1591 //Wait that subs is cleaned
1592 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1594 xappConn1.TestMsgChanEmpty(t)
1595 xappConn2.TestMsgChanEmpty(t)
1596 e2termConn1.TestMsgChanEmpty(t)
1597 mainCtrl.wait_registry_empty(t, 10)
1600 //-----------------------------------------------------------------------------
1601 // TestSubReqAndSubDelNokSameActionParallel
1604 // +-------+ +-------+ +---------+ +---------+
1605 // | xapp2 | | xapp1 | | submgr | | e2term |
1606 // +-------+ +-------+ +---------+ +---------+
1611 // | |------------->| |
1614 // | | |------------->|
1616 // |--------------------------->| |
1618 // | | |<-------------|
1620 // | | | SubDelReq |
1621 // | | |------------->|
1622 // | | | SubDelResp |
1623 // | | |<-------------|
1626 // | |<-------------| |
1629 // |<---------------------------| |
1631 //-----------------------------------------------------------------------------
1632 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1633 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1636 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1638 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1640 // E2t: Receive SubsReq (first)
1641 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1644 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1646 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1647 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1648 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1650 // E2t: send SubsFail (first)
1651 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1652 fparams1.Set(crereq1)
1653 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1655 // E2t: internal delete
1656 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1657 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1660 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1662 xappConn2.RecvSubsFail(t, cretrans2)
1664 //Wait that subs is cleaned
1665 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1667 xappConn1.TestMsgChanEmpty(t)
1668 xappConn2.TestMsgChanEmpty(t)
1669 e2termConn1.TestMsgChanEmpty(t)
1670 mainCtrl.wait_registry_empty(t, 10)
1673 //-----------------------------------------------------------------------------
1674 // TestSubReqAndSubDelNoAnswerSameActionParallel
1677 // +-------+ +-------+ +---------+ +---------+
1678 // | xapp2 | | xapp1 | | submgr | | e2term |
1679 // +-------+ +-------+ +---------+ +---------+
1684 // | |------------->| |
1687 // | | |------------->|
1689 // |--------------------------->| |
1692 // | | |------------->|
1695 // | | | SubDelReq |
1696 // | | |------------->|
1698 // | | | SubDelResp |
1699 // | | |<-------------|
1701 //-----------------------------------------------------------------------------
1702 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1703 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1706 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1708 xappConn1.SendSubsReq(t, rparams1, nil)
1710 crereq1, _ := e2termConn1.RecvSubsReq(t)
1713 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1715 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1716 xappConn2.SendSubsReq(t, rparams2, nil)
1717 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1719 //Req1 (retransmitted)
1720 e2termConn1.RecvSubsReq(t)
1722 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1723 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1725 //Wait that subs is cleaned
1726 mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10)
1728 xappConn1.TestMsgChanEmpty(t)
1729 xappConn2.TestMsgChanEmpty(t)
1730 e2termConn1.TestMsgChanEmpty(t)
1731 mainCtrl.wait_registry_empty(t, 15)
1734 //----------------------------- Policy cases ---------------------------------
1735 //-----------------------------------------------------------------------------
1736 // TestSubReqPolicyAndSubDelOk
1739 // +-------+ +---------+ +---------+
1740 // | xapp | | submgr | | e2term |
1741 // +-------+ +---------+ +---------+
1744 // |------------->| |
1747 // | |------------->|
1750 // | |<-------------|
1753 // |<-------------| |
1757 // |------------->| |
1760 // | |------------->|
1763 // | |<-------------|
1766 // |<-------------| |
1768 //-----------------------------------------------------------------------------
1769 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
1770 CaseBegin("TestSubReqAndSubDelOk")
1772 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1774 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1775 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1777 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1778 e2termConn1.SendSubsResp(t, crereq, cremsg)
1779 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1780 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1781 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1783 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1784 xappConn1.RecvSubsDelResp(t, deltrans)
1786 //Wait that subs is cleaned
1787 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1789 xappConn1.TestMsgChanEmpty(t)
1790 xappConn2.TestMsgChanEmpty(t)
1791 e2termConn1.TestMsgChanEmpty(t)
1792 mainCtrl.wait_registry_empty(t, 10)
1795 //-----------------------------------------------------------------------------
1796 // TestSubReqPolicyChangeAndSubDelOk
1799 // +-------+ +---------+ +---------+
1800 // | xapp | | submgr | | e2term |
1801 // +-------+ +---------+ +---------+
1804 // |------------->| |
1807 // | |------------->|
1810 // | |<-------------|
1813 // |<-------------| |
1816 // |------------->| |
1819 // | |------------->|
1822 // | |<-------------|
1825 // |<-------------| |
1828 // |------------->| |
1831 // | |------------->|
1834 // | |<-------------|
1837 // |<-------------| |
1839 //-----------------------------------------------------------------------------
1841 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
1842 CaseBegin("TestSubReqAndSubDelOk")
1844 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1846 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1847 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1849 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1850 e2termConn1.SendSubsResp(t, crereq, cremsg)
1851 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1854 rparams1.Req.RequestId.InstanceId = e2SubsId
1855 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
1856 xappConn1.SendSubsReq(t, rparams1, cretrans)
1858 crereq, cremsg = e2termConn1.RecvSubsReq(t)
1859 e2termConn1.SendSubsResp(t, crereq, cremsg)
1860 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1861 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1862 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1864 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1865 xappConn1.RecvSubsDelResp(t, deltrans)
1867 //Wait that subs is cleaned
1868 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1870 xappConn1.TestMsgChanEmpty(t)
1871 xappConn2.TestMsgChanEmpty(t)
1872 e2termConn1.TestMsgChanEmpty(t)
1873 mainCtrl.wait_registry_empty(t, 10)
1876 //-----------------------------------------------------------------------------
1877 // TestSubReqAndSubDelOkTwoE2termParallel
1880 // +-------+ +---------+ +---------+ +---------+
1881 // | xapp | | submgr | | e2term1 | | e2term2 |
1882 // +-------+ +---------+ +---------+ +---------+
1887 // |------------->| | |
1890 // | |------------->| |
1893 // |------------->| | |
1896 // | |---------------------------->|
1899 // | |<-------------| |
1901 // |<-------------| | |
1903 // | |<----------------------------|
1905 // |<-------------| | |
1907 // | [SUBS 1 DELETE] | |
1909 // | [SUBS 2 DELETE] | |
1912 //-----------------------------------------------------------------------------
1913 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
1914 CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
1917 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1918 xappConn1.SendSubsReq(t, nil, cretrans1)
1919 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1921 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
1922 xappConn1.SendSubsReq(t, nil, cretrans2)
1923 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
1926 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1927 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1930 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
1931 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1934 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1935 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1936 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1937 xappConn1.RecvSubsDelResp(t, deltrans1)
1938 //Wait that subs is cleaned
1939 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1942 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
1943 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
1944 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
1945 xappConn1.RecvSubsDelResp(t, deltrans2)
1946 //Wait that subs is cleaned
1947 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1949 xappConn1.TestMsgChanEmpty(t)
1950 xappConn2.TestMsgChanEmpty(t)
1951 e2termConn1.TestMsgChanEmpty(t)
1952 e2termConn2.TestMsgChanEmpty(t)
1953 mainCtrl.wait_registry_empty(t, 10)
1956 //-----------------------------------------------------------------------------
1957 // TestSubReqInsertAndSubDelOk
1960 // +-------+ +---------+ +---------+
1961 // | xapp | | submgr | | e2term |
1962 // +-------+ +---------+ +---------+
1965 // |------------->| |
1968 // | |------------->|
1971 // | |<-------------|
1974 // |<-------------| |
1978 // |------------->| |
1981 // | |------------->|
1984 // | |<-------------|
1987 // |<-------------| |
1989 //-----------------------------------------------------------------------------
1990 func TestSubReqInsertAndSubDelOk(t *testing.T) {
1991 CaseBegin("TestInsertSubReqAndSubDelOk")
1993 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1995 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeInsert
1996 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1998 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1999 e2termConn1.SendSubsResp(t, crereq, cremsg)
2000 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2001 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2002 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2004 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2005 xappConn1.RecvSubsDelResp(t, deltrans)
2007 //Wait that subs is cleaned
2008 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2010 xappConn1.TestMsgChanEmpty(t)
2011 xappConn2.TestMsgChanEmpty(t)
2012 e2termConn1.TestMsgChanEmpty(t)
2013 mainCtrl.wait_registry_empty(t, 10)
2016 //-----------------------------------------------------------------------------
2017 // TestSubReqRetransmissionWithSameSubIdDiffXid
2019 // This case simulates case where xApp restarts and starts sending same
2020 // subscription requests which have already subscribed successfully
2023 // +-------+ +---------+ +---------+
2024 // | xapp | | submgr | | e2term |
2025 // +-------+ +---------+ +---------+
2028 // |------------->| |
2031 // | |------------->|
2034 // | |<-------------|
2037 // |<-------------| |
2039 // | xApp restart | |
2042 // | (retrans with same xApp generated subid but diff xid)
2043 // |------------->| |
2046 // |<-------------| |
2048 // | [SUBS DELETE] |
2051 //-----------------------------------------------------------------------------
2052 func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) {
2053 CaseBegin("TestSubReqRetransmissionWithSameSubIdDiffXid")
2056 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2057 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2058 e2termConn1.SendSubsResp(t, crereq, cremsg)
2059 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2061 // xApp restart here
2062 // --> artificial delay
2063 <-time.After(1 * time.Second)
2066 cretrans = xappConn1.SendSubsReq(t, nil, nil) //Retransmitted SubReq
2067 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2070 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2071 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2072 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2073 xappConn1.RecvSubsDelResp(t, deltrans)
2075 //Wait that subs is cleaned
2076 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2078 xappConn1.TestMsgChanEmpty(t)
2079 xappConn2.TestMsgChanEmpty(t)
2080 e2termConn1.TestMsgChanEmpty(t)
2081 mainCtrl.wait_registry_empty(t, 10)
2084 //-----------------------------------------------------------------------------
2085 // TestSubReqNokAndSubDelOkWithRestartInMiddle
2088 // +-------+ +---------+ +---------+
2089 // | xapp | | submgr | | e2term |
2090 // +-------+ +---------+ +---------+
2093 // |------------->| |
2096 // | |------------->|
2101 // | Submgr restart |
2105 // | |------------->|
2108 // | |<-------------|
2111 //-----------------------------------------------------------------------------
2113 func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
2114 CaseBegin("TestSubReqNokAndSubDelOkWithRestartInMiddle")
2116 // Remove possible existing subscrition
2117 mainCtrl.removeExistingSubscriptions(t)
2119 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
2120 xappConn1.SendSubsReq(t, nil, nil)
2121 e2termConn1.RecvSubsReq(t)
2122 mainCtrl.SetResetTestFlag(t, false)
2124 resp, _ := xapp.Subscription.QuerySubscriptions()
2125 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2126 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2127 e2SubsId := uint32(resp[0].SubscriptionID)
2128 t.Logf("e2SubsId = %v", e2SubsId)
2130 mainCtrl.SimulateRestart(t)
2131 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2133 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2134 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2136 // Wait that subs is cleaned
2137 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2139 xappConn1.TestMsgChanEmpty(t)
2140 xappConn2.TestMsgChanEmpty(t)
2141 e2termConn1.TestMsgChanEmpty(t)
2142 mainCtrl.wait_registry_empty(t, 10)
2145 //-----------------------------------------------------------------------------
2146 // TestSubReqAndSubDelOkWithRestartInMiddle
2149 // +-------+ +---------+ +---------+
2150 // | xapp | | submgr | | e2term |
2151 // +-------+ +---------+ +---------+
2154 // |------------->| |
2157 // | |------------->|
2160 // | |<-------------|
2163 // |<-------------| |
2166 // | Submgr restart |
2169 // |------------->| |
2172 // | |------------->|
2175 // | |<-------------|
2178 // |<-------------| |
2180 //-----------------------------------------------------------------------------
2182 func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
2183 CaseBegin("TestSubReqAndSubDelOkWithRestartInMiddle")
2185 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2186 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2187 e2termConn1.SendSubsResp(t, crereq, cremsg)
2188 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2190 // Check subscription
2191 resp, _ := xapp.Subscription.QuerySubscriptions()
2192 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2193 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2194 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2196 mainCtrl.SimulateRestart(t)
2197 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2199 // Check that subscription is restored correctly after restart
2200 resp, _ = xapp.Subscription.QuerySubscriptions()
2201 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2202 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2203 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2205 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2206 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2207 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2208 xappConn1.RecvSubsDelResp(t, deltrans)
2210 //Wait that subs is cleaned
2211 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2213 xappConn1.TestMsgChanEmpty(t)
2214 xappConn2.TestMsgChanEmpty(t)
2215 e2termConn1.TestMsgChanEmpty(t)
2216 mainCtrl.wait_registry_empty(t, 10)
2219 //-----------------------------------------------------------------------------
2220 // TestSubReqAndSubDelOkSameActionWithRestartsInMiddle
2223 // +-------+ +-------+ +---------+ +---------+
2224 // | xapp2 | | xapp1 | | submgr | | e2term |
2225 // +-------+ +-------+ +---------+ +---------+
2230 // | |------------->| |
2233 // | | |------------->|
2235 // | | |<-------------|
2237 // | |<-------------| |
2240 // | submgr restart |
2245 // |--------------------------->| |
2248 // |<---------------------------| |
2250 // | | SubDelReq 1 | |
2251 // | |------------->| |
2253 // | | SubDelResp 1 | |
2254 // | |<-------------| |
2258 // | submgr restart |
2261 // | SubDelReq 2 | |
2262 // |--------------------------->| |
2264 // | | | SubDelReq 2 |
2265 // | | |------------->|
2267 // | | | SubDelReq 2 |
2268 // | | |------------->|
2270 // | SubDelResp 2 | |
2271 // |<---------------------------| |
2273 //-----------------------------------------------------------------------------
2275 func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
2276 CaseBegin("TestSubReqAndSubDelOkSameActionWithRestartsInMiddle")
2279 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2281 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2282 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2283 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2284 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2287 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2289 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2290 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
2292 // Check subscription
2293 resp, _ := xapp.Subscription.QuerySubscriptions() ////////////////////////////////
2294 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2295 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2296 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2298 mainCtrl.SimulateRestart(t)
2299 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2301 // Check that subscription is restored correctly after restart
2302 resp, _ = xapp.Subscription.QuerySubscriptions()
2303 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2304 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2305 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2308 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2309 xapp.Logger.Debug("xappConn1.RecvSubsDelResp")
2310 xappConn1.RecvSubsDelResp(t, deltrans1)
2311 xapp.Logger.Debug("xappConn1.RecvSubsDelResp received")
2313 mainCtrl.SimulateRestart(t)
2314 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2317 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
2318 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2320 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2321 xappConn2.RecvSubsDelResp(t, deltrans2)
2323 //Wait that subs is cleaned
2324 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2326 xappConn1.TestMsgChanEmpty(t)
2327 xappConn2.TestMsgChanEmpty(t)
2328 e2termConn1.TestMsgChanEmpty(t)
2329 mainCtrl.wait_registry_empty(t, 10)
2332 //*****************************************************************************
2333 // REST interface test cases
2334 //*****************************************************************************
2336 //-----------------------------------------------------------------------------
2337 // Test debug GET and POST requests
2340 // +-------+ +---------+
2341 // | user | | submgr |
2342 // +-------+ +---------+
2349 func TestGetSubscriptions(t *testing.T) {
2351 mainCtrl.sendGetRequest(t, "localhost:8088", "/ric/v1/subscriptions")
2354 func TestGetSymptomData(t *testing.T) {
2356 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/symptomdata")
2359 func TestPostdeleteSubId(t *testing.T) {
2361 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/deletesubid=1")
2364 func TestPostEmptyDb(t *testing.T) {
2366 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/emptydb")
2369 //-----------------------------------------------------------------------------
2370 // TestRESTSubReqAndRouteNok
2373 // +-------+ +---------+ +---------+
2374 // | xapp | | submgr | | rtmgr |
2375 // +-------+ +---------+ +---------+
2378 // |---------------->| |
2380 // | RESTSubResp | |
2381 // |<----------------| |
2382 // | | RouteCreate |
2383 // | |------------->|
2385 // | | RouteCreate |
2387 // | |(Bad request) |
2388 // | |<-------------|
2390 // |<----------------| |
2392 // | [SUBS INT DELETE] |
2394 // | RESTSubDelReq | |
2395 // |---------------->| |
2396 // | RESTSubDelResp | |
2397 // |<----------------| |
2399 //-----------------------------------------------------------------------------
2400 func TestRESTSubReqAndRouteNok(t *testing.T) {
2401 CaseBegin("TestRESTSubReqAndRouteNok")
2403 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2404 Counter{cRestSubReqFromXapp, 1},
2405 Counter{cRouteCreateFail, 1},
2406 Counter{cRestSubRespToXapp, 1},
2407 Counter{cRestSubDelReqFromXapp, 1},
2408 Counter{cRestSubDelRespToXapp, 1},
2411 const subReqCount int = 1
2412 // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
2413 waiter := rtmgrHttp.AllocNextSleep(50, false)
2414 newSubsId := mainCtrl.get_registry_next_subid(t)
2417 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2418 restSubId := xappConn1.SendRESTSubsReq(t, params)
2419 xappConn1.ExpectRESTNotification(t, restSubId)
2420 waiter.WaitResult(t)
2422 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2423 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
2426 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2428 // Wait that subs is cleaned
2429 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2430 waitSubsCleanup(t, e2SubsId, 10)
2431 mainCtrl.VerifyCounterValues(t)
2434 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
2435 CaseBegin("TestSubReqAndRouteUpdateNok")
2437 //Init counter check
2438 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2439 Counter{cRestSubReqFromXapp, 2},
2440 Counter{cSubReqToE2, 1},
2441 Counter{cSubRespFromE2, 1},
2442 Counter{cRestSubRespToXapp, 2},
2443 Counter{cRouteCreateUpdateFail, 1},
2444 Counter{cRestSubDelReqFromXapp, 1},
2445 Counter{cSubDelReqToE2, 1},
2446 Counter{cSubDelRespFromE2, 1},
2447 Counter{cRestSubDelRespToXapp, 1},
2450 var params *teststube2ap.RESTSubsReqParams = nil
2453 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2455 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2457 // xapp2 ROUTE creation shall fail with 400 from rtmgr -> submgr
2458 waiter := rtmgrHttp.AllocNextEvent(false)
2459 newSubsId := mainCtrl.get_registry_next_subid(t)
2460 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
2461 params.SetMeid("RAN_NAME_1")
2462 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2463 xapp.Logger.Info("Send REST subscriber request for second subscriber : %v", restSubId2)
2464 xappConn2.ExpectRESTNotification(t, restSubId2)
2465 waiter.WaitResult(t)
2466 // e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) - TOD: missing delete
2467 xappConn2.WaitRESTNotification(t, restSubId2)
2469 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2471 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2473 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2474 //Wait that subs is cleaned
2475 waitSubsCleanup(t, e2SubsId, 10)
2477 mainCtrl.VerifyCounterValues(t)
2480 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
2481 CaseBegin("TestRESTSubDelReqAndRouteDeleteNok")
2483 // Init counter check
2484 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2485 Counter{cRestSubReqFromXapp, 1},
2486 Counter{cSubReqToE2, 1},
2487 Counter{cSubRespFromE2, 1},
2488 Counter{cRestSubRespToXapp, 1},
2489 Counter{cRestSubDelReqFromXapp, 1},
2490 Counter{cRouteDeleteFail, 1},
2491 Counter{cSubDelReqToE2, 1},
2492 Counter{cSubDelRespFromE2, 1},
2493 Counter{cRestSubDelRespToXapp, 1},
2496 var params *teststube2ap.RESTSubsReqParams = nil
2499 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2501 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2503 waiter := rtmgrHttp.AllocNextEvent(false)
2504 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2505 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2506 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2507 waiter.WaitResult(t)
2509 waitSubsCleanup(t, e2SubsId, 10)
2511 mainCtrl.VerifyCounterValues(t)
2514 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
2515 CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok")
2517 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2518 Counter{cRestSubReqFromXapp, 2},
2519 Counter{cSubReqToE2, 1},
2520 Counter{cSubRespFromE2, 1},
2521 Counter{cRestSubRespToXapp, 2},
2522 Counter{cRestSubDelReqFromXapp, 2},
2523 Counter{cRouteDeleteUpdateFail, 1},
2524 Counter{cSubDelReqToE2, 1},
2525 Counter{cSubDelRespFromE2, 1},
2526 Counter{cRestSubDelRespToXapp, 2},
2529 var params *teststube2ap.RESTSubsReqParams = nil
2532 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2534 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2535 restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1")
2537 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
2539 //Del1, this shall fail on rtmgr side
2540 waiter := rtmgrHttp.AllocNextEvent(false)
2541 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2542 waiter.WaitResult(t)
2544 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"})
2547 deleteXapp2Subscription(t, &restSubId2)
2549 waitSubsCleanup(t, e2SubsId2, 10)
2551 mainCtrl.VerifyCounterValues(t)
2554 //-----------------------------------------------------------------------------
2555 // TestRESTSubReqRetransmission
2558 // +-------+ +---------+ +---------+
2559 // | xapp | | submgr | | e2term |
2560 // +-------+ +---------+ +---------+
2562 // | RESTSubReq1 | |
2563 // |---------------->| |
2565 // | RESTSubResp | |
2566 // |<----------------| |
2568 // | |------------->|
2570 // | RESTSubReq2 | |
2572 // |---------------->| |
2575 // | |------------->|
2576 // | RESTSubResp2 | |
2577 // |<----------------| |
2579 // | |<-------------|
2581 // |<----------------| |
2583 // | |<-------------|
2585 // |<----------------| |
2587 // | [SUBS DELETE] |
2590 //-----------------------------------------------------------------------------
2592 func TestRESTSubReqRetransmission(t *testing.T) {
2593 CaseBegin("TestRESTSubReqRetransmission")
2595 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2596 Counter{cRestSubReqFromXapp, 2},
2597 Counter{cSubReqToE2, 2},
2598 Counter{cSubRespFromE2, 2},
2599 Counter{cRestSubRespToXapp, 2},
2600 Counter{cRestSubDelReqFromXapp, 2},
2601 Counter{cSubDelReqToE2, 2},
2602 Counter{cSubDelRespFromE2, 2},
2603 Counter{cRestSubDelRespToXapp, 2},
2605 // Retry/duplicate will get the same way as the first request. Submgr cannot detect duplicate RESTRequests
2606 // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
2607 // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
2610 const subReqCount int = 1
2612 // In order to force both XAPP's to create their own subscriptions, force rtmgr to block a while so that 2nd create
2613 // gets into execution before the rtmgrg responds for the first one.
2614 waiter := rtmgrHttp.AllocNextSleep(10, true)
2615 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2616 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
2617 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2619 waiter.WaitResult(t)
2621 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
2623 // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
2624 // the order is not significant he6re.
2625 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2626 e2termConn1.SendSubsResp(t, crereq, cremsg)
2627 crereq, cremsg = e2termConn1.RecvSubsReq(t)
2628 e2termConn1.SendSubsResp(t, crereq, cremsg)
2630 e2SubsIdA := <-xappConn1.ListedRESTNotifications
2631 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
2632 e2SubsIdB := <-xappConn1.ListedRESTNotifications
2633 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
2636 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
2637 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2638 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2641 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
2642 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2643 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2645 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
2647 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
2649 mainCtrl.VerifyCounterValues(t)
2652 func TestRESTSubDelReqRetransmission(t *testing.T) {
2653 CaseBegin("TestRESTSubDelReqRetransmission")
2655 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2656 Counter{cRestSubReqFromXapp, 1},
2657 Counter{cSubReqToE2, 1},
2658 Counter{cSubRespFromE2, 1},
2659 Counter{cRestSubRespToXapp, 1},
2660 Counter{cRestSubDelReqFromXapp, 2},
2661 Counter{cSubDelReqToE2, 1},
2662 Counter{cSubDelRespFromE2, 1},
2663 Counter{cRestSubDelRespToXapp, 1},
2666 var params *teststube2ap.RESTSubsReqParams = nil
2669 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2671 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2674 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2675 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2677 seqBef := mainCtrl.get_msgcounter(t)
2678 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2679 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
2681 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2683 waitSubsCleanup(t, e2SubsId, 10)
2685 mainCtrl.VerifyCounterValues(t)
2688 //-----------------------------------------------------------------------------
2689 // TestRESTSubReqDelReq
2692 // +-------+ +---------+ +---------+
2693 // | xapp | | submgr | | e2term |
2694 // +-------+ +---------+ +---------+
2697 // |---------------->| |
2699 // | RESTSubResp | |
2700 // |<----------------| |
2702 // | |------------->|
2703 // | RESTSubDelReq | |
2704 // |---------------->| |
2705 // | RESTSubDelResp | |
2707 // |<----------------| |
2709 // | |<-------------|
2711 // |<----------------| |
2713 // | [SUBS DELETE] |
2716 //-----------------------------------------------------------------------------
2717 func TestRESTSubReqDelReq(t *testing.T) {
2718 CaseBegin("TestRESTSubReqDelReq")
2720 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2721 Counter{cRestSubReqFromXapp, 1},
2722 Counter{cSubReqToE2, 1},
2723 Counter{cSubRespFromE2, 1},
2724 Counter{cRestSubRespToXapp, 1},
2725 Counter{cRestSubDelReqFromXapp, 2},
2726 Counter{cSubDelReqToE2, 1},
2727 Counter{cSubDelRespFromE2, 1},
2728 Counter{cRestSubDelRespToXapp, 1},
2731 const subReqCount int = 1
2734 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2735 restSubId := xappConn1.SendRESTSubsReq(t, params)
2737 // Del. This will fail as processing of the subscription
2738 // is still ongoing in submgr. Deletion is not allowed before
2739 // subscription creation has been completed.
2740 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2741 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2742 xappConn1.ExpectRESTNotification(t, restSubId)
2743 e2termConn1.SendSubsResp(t, crereq, cremsg)
2744 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2747 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2749 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2750 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2752 // Wait that subs is cleaned
2753 waitSubsCleanup(t, e2SubsId, 10)
2754 mainCtrl.VerifyCounterValues(t)
2758 func TestRESTSubDelReqCollision(t *testing.T) {
2759 CaseBegin("TestRESTSubDelReqCollision - not relevant for REST API")
2762 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
2763 CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel")
2765 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2766 Counter{cRestSubReqFromXapp, 2},
2767 Counter{cSubReqToE2, 2},
2768 Counter{cSubRespFromE2, 2},
2769 Counter{cRestSubRespToXapp, 2},
2770 Counter{cRestSubDelReqFromXapp, 2},
2771 Counter{cSubDelReqToE2, 2},
2772 Counter{cSubDelRespFromE2, 2},
2773 Counter{cRestSubDelRespToXapp, 2},
2777 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2778 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
2779 xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
2782 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
2783 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2784 xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
2786 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2787 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
2789 //XappConn1 receives both of the responses
2790 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
2793 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2795 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
2797 e2SubsIdA := <-xappConn1.ListedRESTNotifications
2798 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
2799 e2SubsIdB := <-xappConn1.ListedRESTNotifications
2800 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
2803 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
2805 deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
2807 //Wait that subs is cleaned
2808 mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
2809 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
2811 mainCtrl.VerifyCounterValues(t)
2815 func TestRESTSameSubsDiffRan(t *testing.T) {
2816 CaseBegin("TestRESTSameSubsDiffRan")
2818 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2819 Counter{cRestSubReqFromXapp, 2},
2820 Counter{cSubReqToE2, 2},
2821 Counter{cSubRespFromE2, 2},
2822 Counter{cRestSubRespToXapp, 2},
2823 Counter{cRestSubDelReqFromXapp, 2},
2824 Counter{cSubDelReqToE2, 2},
2825 Counter{cSubDelRespFromE2, 2},
2826 Counter{cRestSubDelRespToXapp, 2},
2829 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2830 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
2831 xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
2833 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
2834 params.SetMeid("RAN_NAME_2")
2835 restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
2836 xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
2839 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
2841 deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
2843 //Wait that subs is cleaned
2844 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
2845 waitSubsCleanup(t, e2SubsId2, 10)
2847 mainCtrl.VerifyCounterValues(t)
2851 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
2852 CaseBegin("TestRESTSubReqRetryInSubmgr start")
2854 // Init counter check
2855 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2856 Counter{cRestSubReqFromXapp, 1},
2857 Counter{cSubReqToE2, 1},
2858 Counter{cSubReReqToE2, 1},
2859 Counter{cSubRespFromE2, 1},
2860 Counter{cRestSubRespToXapp, 1},
2861 Counter{cRestSubDelReqFromXapp, 1},
2862 Counter{cSubDelReqToE2, 1},
2863 Counter{cSubDelRespFromE2, 1},
2864 Counter{cRestSubDelRespToXapp, 1},
2867 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2868 restSubId := xappConn1.SendRESTSubsReq(t, params)
2870 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
2872 // Catch the first message and ignore it
2873 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2874 xapp.Logger.Info("Ignore REST subscriber request for subscriber : %v", restSubId)
2876 // The second request is being handled normally
2877 crereq, cremsg = e2termConn1.RecvSubsReq(t)
2878 xappConn1.ExpectRESTNotification(t, restSubId)
2879 e2termConn1.SendSubsResp(t, crereq, cremsg)
2880 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2882 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2884 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2886 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2887 //Wait that subs is cleaned
2888 waitSubsCleanup(t, e2SubsId, 10)
2890 mainCtrl.VerifyCounterValues(t)
2894 //-----------------------------------------------------------------------------
2895 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
2898 // +-------+ +---------+ +---------+
2899 // | xapp | | submgr | | e2term |
2900 // +-------+ +---------+ +---------+
2903 // |---------------->| |
2905 // | RESTSubResp | |
2906 // |<----------------| |
2908 // | |------------->|
2912 // | |------------->|
2915 // | |------------->|
2919 // | |------------->|
2923 // | |<-------------|
2926 // |<----------------| |
2928 // | [SUBS DELETE] |
2931 //-----------------------------------------------------------------------------
2932 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
2933 CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
2935 // Init counter check
2936 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2937 Counter{cRestSubReqFromXapp, 1},
2938 Counter{cSubReqToE2, 1},
2939 Counter{cSubReReqToE2, 1},
2940 Counter{cSubReqTimerExpiry, 2},
2941 Counter{cSubDelReqToE2, 1},
2942 Counter{cSubDelRespFromE2, 1},
2945 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2946 restSubId := xappConn1.SendRESTSubsReq(t, params)
2947 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
2949 e2termConn1.RecvSubsReq(t)
2950 xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
2952 e2termConn1.RecvSubsReq(t)
2953 xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
2955 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2956 xappConn1.ExpectRESTNotification(t, restSubId)
2957 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2958 // e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) - TODO: Should we delete this?
2959 xappConn1.WaitRESTNotification(t, restSubId)
2961 // Wait that subs is cleaned
2962 waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
2964 mainCtrl.VerifyCounterValues(t)
2967 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
2968 CaseBegin("TestREST2eTermNotRespondingToSubReq start")
2970 // Init counter check
2971 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2972 Counter{cRestSubReqFromXapp, 1},
2973 Counter{cSubReqToE2, 1},
2974 Counter{cSubReReqToE2, 1},
2975 Counter{cSubReqTimerExpiry, 2},
2976 Counter{cSubDelReqToE2, 1},
2977 Counter{cSubDelReqTimerExpiry, 2},
2980 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2981 restSubId := xappConn1.SendRESTSubsReq(t, params)
2982 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
2984 e2termConn1.RecvSubsReq(t)
2985 xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
2987 e2termConn1.RecvSubsReq(t)
2988 xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
2990 e2termConn1.RecvSubsDelReq(t)
2991 xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
2993 xappConn1.ExpectRESTNotification(t, restSubId)
2994 e2termConn1.RecvSubsDelReq(t)
2995 xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
2997 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2999 waitSubsCleanup(t, e2SubsId, 10)
3001 mainCtrl.VerifyCounterValues(t)
3005 //-----------------------------------------------------------------------------
3006 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3009 // +-------+ +---------+ +---------+
3010 // | xapp | | submgr | | e2term |
3011 // +-------+ +---------+ +---------+
3014 // |---------------->| |
3016 // | RESTSubResp | |
3017 // |<----------------| |
3019 // | |------------->|
3023 // | |------------->|
3026 // | |------------->|
3030 // | |------------->|
3034 // | |<-------------|
3037 // |<----------------| |
3039 // | [SUBS DELETE] |
3042 //-----------------------------------------------------------------------------
3043 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
3044 CaseBegin("TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr start")
3046 // Init counter check
3047 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3048 Counter{cRestSubReqFromXapp, 1},
3049 Counter{cSubReqToE2, 1},
3050 Counter{cSubReReqToE2, 1},
3051 Counter{cSubReqTimerExpiry, 2},
3052 Counter{cSubDelReqToE2, 1},
3053 Counter{cSubDelReReqToE2, 1},
3054 Counter{cSubDelReqTimerExpiry, 2},
3057 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3058 restSubId := xappConn1.SendRESTSubsReq(t, params)
3059 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
3061 e2termConn1.RecvSubsReq(t)
3062 xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3064 e2termConn1.RecvSubsReq(t)
3065 xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3067 e2termConn1.RecvSubsDelReq(t)
3068 xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3070 xappConn1.ExpectRESTNotification(t, restSubId)
3071 e2termConn1.RecvSubsDelReq(t)
3072 xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3074 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3076 waitSubsCleanup(t, e2SubsId, 10)
3078 mainCtrl.VerifyCounterValues(t)
3081 //-----------------------------------------------------------------------------
3082 // TestRESTSubReqSubFailRespInSubmgr
3085 // +-------+ +---------+ +---------+
3086 // | xapp | | submgr | | e2term |
3087 // +-------+ +---------+ +---------+
3090 // |---------------->| |
3092 // | RESTSubResp | |
3093 // |<----------------| |
3095 // | |------------->|
3098 // | |<-------------|
3101 // | |------------->|
3104 // | |<-------------|
3108 // |<----------------| |
3110 // | [SUBS DELETE] |
3113 //-----------------------------------------------------------------------------
3114 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
3115 CaseBegin("TestRESTSubReqSubFailRespInSubmgr")
3117 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3118 Counter{cRestSubReqFromXapp, 1},
3119 Counter{cSubReqToE2, 1},
3120 Counter{cSubFailFromE2, 1},
3121 Counter{cRestSubRespToXapp, 1},
3122 Counter{cRestSubDelReqFromXapp, 1},
3125 const subReqCount int = 1
3127 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3128 restSubId := xappConn1.SendRESTSubsReq(t, params)
3130 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3131 fparams1 := &teststube2ap.E2StubSubsFailParams{}
3132 fparams1.Set(crereq1)
3133 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3135 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3136 xappConn1.ExpectRESTNotification(t, restSubId)
3137 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3138 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3139 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
3141 // REST subscription sill there to be deleted
3142 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3144 // Wait that subs is cleaned
3145 waitSubsCleanup(t, e2SubsId, 10)
3147 mainCtrl.VerifyCounterValues(t)
3151 //-----------------------------------------------------------------------------
3152 // TestRESTSubDelReqRetryInSubmgr
3155 // +-------+ +---------+ +---------+
3156 // | xapp | | submgr | | e2term |
3157 // +-------+ +---------+ +---------+
3159 // | [SUBS CREATE] |
3162 // | RESTSubDelReq | |
3163 // |---------------->| |
3165 // | RESTSubDelResp | |
3166 // |<----------------| |
3168 // | |------------->|
3171 // | |------------->|
3174 // | |<-------------|
3177 //-----------------------------------------------------------------------------
3178 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
3179 CaseBegin("TestRESTSubDelReqRetryInSubmgr")
3181 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3182 Counter{cRestSubReqFromXapp, 1},
3183 Counter{cSubReqToE2, 1},
3184 Counter{cSubRespFromE2, 1},
3185 Counter{cRestSubRespToXapp, 1},
3186 Counter{cRestSubDelReqFromXapp, 1},
3187 Counter{cSubDelReqToE2, 1},
3188 Counter{cSubDelReReqToE2, 1},
3189 Counter{cSubDelRespFromE2, 1},
3190 Counter{cRestSubDelRespToXapp, 1},
3193 var params *teststube2ap.RESTSubsReqParams = nil
3194 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3197 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3199 // E2t: Receive 1st SubsDelReq
3200 e2termConn1.RecvSubsDelReq(t)
3202 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
3203 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3204 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3206 //Wait that subs is cleaned
3207 waitSubsCleanup(t, e2SubsId, 10)
3209 mainCtrl.VerifyCounterValues(t)
3212 //-----------------------------------------------------------------------------
3213 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
3216 // +-------+ +---------+ +---------+
3217 // | xapp | | submgr | | e2term |
3218 // +-------+ +---------+ +---------+
3220 // | [SUBS CREATE] |
3223 // | RESTSubDelReq | |
3224 // |---------------->| |
3226 // | RESTSubDelResp | |
3227 // |<----------------| |
3229 // | |------------->|
3232 // | |------------->|
3236 //-----------------------------------------------------------------------------
3237 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
3238 CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr")
3240 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3241 Counter{cRestSubReqFromXapp, 1},
3242 Counter{cSubReqToE2, 1},
3243 Counter{cSubRespFromE2, 1},
3244 Counter{cRestSubRespToXapp, 1},
3245 Counter{cRestSubDelReqFromXapp, 1},
3246 Counter{cSubDelReqToE2, 1},
3247 Counter{cSubDelReReqToE2, 1},
3248 Counter{cSubDelRespFromE2, 1},
3249 Counter{cRestSubDelRespToXapp, 1},
3253 var params *teststube2ap.RESTSubsReqParams = nil
3254 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3257 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3259 // E2t: Receive 1st SubsDelReq
3260 e2termConn1.RecvSubsDelReq(t)
3262 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
3263 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3264 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3266 //Wait that subs is cleaned
3267 waitSubsCleanup(t, e2SubsId, 10)
3269 mainCtrl.VerifyCounterValues(t)
3272 //-----------------------------------------------------------------------------
3273 // TestRESTSubDelReqSubDelFailRespInSubmgr
3276 // +-------+ +---------+ +---------+
3277 // | xapp | | submgr | | e2term |
3278 // +-------+ +---------+ +---------+
3280 // | [SUBS CREATE] |
3283 // | RESTSubDelReq | |
3284 // |---------------->| |
3286 // | RESTSubDelResp | |
3287 // |<----------------| |
3289 // | |------------->|
3292 // | |<-------------|
3295 //-----------------------------------------------------------------------------
3296 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
3297 CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr")
3299 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3300 Counter{cRestSubReqFromXapp, 1},
3301 Counter{cSubReqToE2, 1},
3302 Counter{cSubRespFromE2, 1},
3303 Counter{cRestSubRespToXapp, 1},
3304 Counter{cRestSubDelReqFromXapp, 1},
3305 Counter{cSubDelReqToE2, 1},
3306 Counter{cSubDelFailFromE2, 1},
3307 Counter{cRestSubDelRespToXapp, 1},
3311 var params *teststube2ap.RESTSubsReqParams = nil
3312 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3315 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3317 // E2t: Send receive SubsDelReq and send SubsDelFail
3318 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3319 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
3321 //Wait that subs is cleaned
3322 waitSubsCleanup(t, e2SubsId, 10)
3324 mainCtrl.VerifyCounterValues(t)
3327 //-----------------------------------------------------------------------------
3328 // TestRESTSubReqAndSubDelOkSameAction
3331 // +-------+ +-------+ +---------+ +---------+
3332 // | xapp2 | | xapp1 | | submgr | | e2term |
3333 // +-------+ +-------+ +---------+ +---------+
3335 // | | RESTSubReq1 | |
3336 // | |---------------->| |
3338 // | | RESTSubResp1 | |
3339 // | |<----------------| |
3342 // | | |------------->|
3344 // | | |<-------------|
3345 // | | RESTNotif1 | |
3346 // | |<----------------| |
3348 // | RESTSubReq2 | |
3349 // |------------------------------>| |
3351 // | RESTSubResp2 | |
3352 // |<------------------------------| |
3354 // | | RESTNotif2 | |
3355 // |<------------------------------| |
3357 // | | RESTSubDelReq1 | |
3358 // | |---------------->| |
3360 // | | RESTSubDelResp1 | |
3361 // | |<----------------| |
3363 // | RESTSubDelReq2 | |
3364 // |------------------------------>| |
3366 // | RESTSubDelResp2 | |
3367 // |<------------------------------| |
3369 // | | | SubDelReq2 |
3370 // | | |------------->|
3372 // | | | SubDelResp2 |
3373 // | | |<-------------|
3376 //-----------------------------------------------------------------------------
3377 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
3378 CaseBegin("TestRESTSubReqAndSubDelOkSameAction")
3380 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3381 Counter{cRestSubReqFromXapp, 2},
3382 Counter{cSubReqToE2, 1},
3383 Counter{cSubRespFromE2, 1},
3384 Counter{cRestSubRespToXapp, 2},
3385 Counter{cMergedSubscriptions, 1},
3386 Counter{cUnmergedSubscriptions, 1},
3387 Counter{cRestSubDelReqFromXapp, 2},
3388 Counter{cSubDelReqToE2, 1},
3389 Counter{cSubDelRespFromE2, 1},
3390 Counter{cRestSubDelRespToXapp, 2},
3394 var params *teststube2ap.RESTSubsReqParams = nil
3397 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3398 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
3401 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3402 params.SetMeid("RAN_NAME_1")
3404 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
3405 xappConn2.WaitRESTNotificationForAnySubscriptionId(t)
3406 waiter := rtmgrHttp.AllocNextSleep(10, true)
3407 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3408 waiter.WaitResult(t)
3409 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
3410 e2SubsId2 := <-xappConn2.RESTNotification
3411 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
3413 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
3416 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3419 deleteXapp2Subscription(t, &restSubId2)
3421 //Wait that subs is cleaned
3422 waitSubsCleanup(t, e2SubsId2, 10)
3424 mainCtrl.VerifyCounterValues(t)
3427 //-----------------------------------------------------------------------------
3428 // TestSubReqAndSubDelOkSameActionParallel
3431 // +-------+ +-------+ +---------+ +---------+
3432 // | xapp2 | | xapp1 | | submgr | | e2term |
3433 // +-------+ +-------+ +---------+ +---------+
3438 // | |------------->| |
3441 // | | |------------->|
3443 // |--------------------------->| |
3445 // | | |<-------------|
3447 // | |<-------------| |
3449 // | | |------------->|
3452 // | | |<-------------|
3454 // |<---------------------------| |
3456 // | | SubDelReq 1 | |
3457 // | |------------->| |
3459 // | | SubDelResp 1 | |
3460 // | |<-------------| |
3462 // | SubDelReq 2 | |
3463 // |--------------------------->| |
3465 // | | | SubDelReq 2 |
3466 // | | |------------->|
3468 // | | | SubDelReq 2 |
3469 // | | |------------->|
3471 // | SubDelResp 2 | |
3472 // |<---------------------------| |
3474 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
3475 CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel")
3477 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3478 Counter{cRestSubReqFromXapp, 2},
3479 Counter{cSubReqToE2, 2},
3480 Counter{cSubRespFromE2, 2},
3481 Counter{cRestSubRespToXapp, 2},
3482 Counter{cRestSubDelReqFromXapp, 2},
3483 Counter{cSubDelReqToE2, 2},
3484 Counter{cSubDelRespFromE2, 2},
3485 Counter{cRestSubDelRespToXapp, 2},
3488 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3489 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3490 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3492 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
3493 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
3495 xappConn1.ExpectRESTNotification(t, restSubId1)
3496 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3497 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
3499 xappConn2.ExpectRESTNotification(t, restSubId2)
3500 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3501 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3502 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
3505 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3506 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3507 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3508 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3511 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
3512 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
3513 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
3515 waitSubsCleanup(t, e2SubsId2, 10)
3517 mainCtrl.VerifyCounterValues(t)
3520 //-----------------------------------------------------------------------------
3521 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
3524 // +-------+ +-------+ +---------+ +---------+
3525 // | xapp2 | | xapp1 | | submgr | | e2term |
3526 // +-------+ +-------+ +---------+ +---------+
3530 // | | RESTSubReq1 | |
3531 // | |---------------->| |
3533 // | | RESTSubResp1 | |
3534 // | |<----------------| |
3536 // | | |------------->|
3537 // | RESTSubReq2 | |
3538 // |------------------------------>| |
3540 // | RESTSubDelResp2 | |
3541 // |<------------------------------| |
3543 // | | |------------->|
3546 // | | | SubDelReq |
3547 // | | |------------->|
3549 // | | | SubDelResp |
3550 // | | |<-------------|
3551 // | | RESTNotif1 | |
3552 // | | unsuccess | |
3553 // | |<----------------| |
3555 // | | unsuccess | |
3556 // |<------------------------------| |
3558 // | | RESTSubDelReq1 | |
3559 // | |---------------->| |
3561 // | | RESTSubDelResp1 | |
3562 // | |<----------------| |
3564 // | RESTSubDelReq2 | |
3565 // |------------------------------>| |
3567 // | RESTSubDelResp2 | |
3568 // |<------------------------------| |
3570 //-----------------------------------------------------------------------------
3571 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
3572 CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
3574 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3575 Counter{cRestSubReqFromXapp, 2},
3576 Counter{cSubReqToE2, 1},
3577 Counter{cRestSubRespToXapp, 2},
3578 Counter{cRestSubDelReqFromXapp, 2},
3579 Counter{cSubDelReqToE2, 1},
3580 Counter{cSubDelRespFromE2, 1},
3581 Counter{cRestSubDelRespToXapp, 2},
3584 const subReqCount int = 1
3587 params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3588 restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
3589 crereq1, _ := e2termConn1.RecvSubsReq(t)
3592 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
3593 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
3594 params2.SetMeid("RAN_NAME_1")
3595 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
3596 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
3598 //Req1 (retransmitted)
3599 e2termConn1.RecvSubsReq(t)
3601 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3603 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3604 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3606 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3607 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3608 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3609 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3612 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3615 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
3617 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
3619 //Wait that subs is cleaned
3620 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
3622 mainCtrl.VerifyCounterValues(t)
3625 //-----------------------------------------------------------------------------
3626 // TestRESTSubReqAndSubDelNokSameActionParallel
3629 // +-------+ +-------+ +---------+ +---------+
3630 // | xapp2 | | xapp1 | | submgr | | e2term |
3631 // +-------+ +-------+ +---------+ +---------+
3635 // | | RESTSubReq1 | |
3636 // | |---------------->| |
3638 // | | RESTSubResp1 | |
3639 // | |<----------------| |
3641 // | | |------------->|
3642 // | RESTSubReq2 | |
3643 // |------------------------------>| |
3645 // | RESTSubDelResp2 | |
3646 // |<------------------------------| |
3648 // | | |<-------------|
3650 // | | RESTNotif1 | |
3651 // | | unsuccess | |
3652 // | |<----------------| |
3654 // | | unsuccess | |
3655 // |<------------------------------| |
3656 // | | | SubDelReq |
3657 // | | |------------->|
3658 // | | | SubDelResp |
3659 // | | |<-------------|
3661 // | | RESTSubDelReq1 | |
3662 // | |---------------->| |
3664 // | | RESTSubDelResp1 | |
3665 // | |<----------------| |
3667 // | RESTSubDelReq2 | |
3668 // |------------------------------>| |
3670 // | RESTSubDelResp2 | |
3671 // |<------------------------------| |
3673 //-----------------------------------------------------------------------------
3674 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
3675 CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
3677 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3678 Counter{cRestSubReqFromXapp, 2},
3679 Counter{cSubReqToE2, 1},
3680 Counter{cSubFailFromE2, 1},
3681 Counter{cRestSubRespToXapp, 2},
3682 Counter{cRestSubDelReqFromXapp, 2},
3683 Counter{cSubDelReqToE2, 1},
3684 Counter{cSubDelRespFromE2, 1},
3685 Counter{cRestSubDelRespToXapp, 2},
3688 const subReqCount int = 1
3691 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3692 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3693 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3696 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
3697 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
3698 params2.SetMeid("RAN_NAME_1")
3699 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
3700 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
3702 // E2t: send SubsFail (first)
3703 fparams1 := &teststube2ap.E2StubSubsFailParams{}
3704 fparams1.Set(crereq1)
3705 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3707 // E2t: internal delete
3708 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3709 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3710 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3712 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3713 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3714 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3715 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3718 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3721 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
3723 //Wait that subs is cleaned
3724 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
3725 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
3727 mainCtrl.VerifyCounterValues(t)
3730 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
3731 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
3733 // Init counter check
3734 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3735 Counter{cRestSubReqFromXapp, 1},
3736 Counter{cSubReqToE2, 1},
3737 Counter{cSubRespFromE2, 1},
3738 Counter{cRestSubRespToXapp, 1},
3739 Counter{cRestSubDelReqFromXapp, 1},
3740 Counter{cSubDelReqToE2, 1},
3741 Counter{cSubDelRespFromE2, 1},
3742 Counter{cRestSubDelRespToXapp, 1},
3745 const subReqCount int = 1
3747 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
3748 restSubId := xappConn1.SendRESTSubsReq(t, params)
3749 xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
3751 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3752 xappConn1.ExpectRESTNotification(t, restSubId)
3753 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3754 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3755 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
3757 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3758 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3759 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3761 // Wait that subs is cleaned
3762 waitSubsCleanup(t, e2SubsId, 10)
3763 mainCtrl.VerifyCounterValues(t)
3766 //-----------------------------------------------------------------------------
3767 // TestRESTSubReqPolicyChangeAndSubDelOk
3770 // +-------+ +---------+ +---------+
3771 // | xapp | | submgr | | e2term |
3772 // +-------+ +---------+ +---------+
3775 // |---------------->| |
3777 // | RESTSubResp | |
3778 // |<----------------| |
3780 // | |------------->|
3783 // | |<-------------|
3786 // |<----------------| |
3789 // |---------------->| |
3791 // | RESTSubResp | |
3792 // |<----------------| |
3794 // | |------------->|
3797 // | |<-------------|
3800 // |<----------------| |
3802 // | RESTSubDelReq | |
3803 // |---------------->| |
3806 // | |------------->|
3809 // | |<-------------|
3811 // | RESTSubDelResp | |
3812 // |<----------------| |
3814 //-----------------------------------------------------------------------------
3815 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
3816 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
3818 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3819 Counter{cRestSubReqFromXapp, 2},
3820 Counter{cSubReqToE2, 2},
3821 Counter{cSubRespFromE2, 2},
3822 Counter{cRestSubRespToXapp, 2},
3823 Counter{cRestSubDelReqFromXapp, 1},
3824 Counter{cSubDelReqToE2, 1},
3825 Counter{cSubDelRespFromE2, 1},
3826 Counter{cRestSubDelRespToXapp, 1},
3829 const subReqCount int = 1
3832 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
3833 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3836 instanceId := int64(e2SubsId)
3837 // GetRESTSubsReqPolicyParams sets some coutners on tc side.
3838 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
3839 params.SubsReqParams.SubscriptionDetails[0].InstanceID = &instanceId
3840 params.SetTimeToWait("w200ms")
3841 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
3844 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3846 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3847 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3849 // Wait that subs is cleaned
3850 waitSubsCleanup(t, e2SubsId, 10)
3851 mainCtrl.VerifyCounterValues(t)
3854 //-----------------------------------------------------------------------------
3855 // TestRESTSubReqAndSubDelOkTwoE2termParallel
3858 // +-------+ +---------+ +---------+ +---------+
3859 // | xapp | | submgr | | e2term1 | | e2term2 |
3860 // +-------+ +---------+ +---------+ +---------+
3864 // | RESTSubReq1 | | |
3865 // |---------------->| | |
3867 // | RESTSubResp1 | | |
3868 // |<----------------| | |
3870 // | |------------->| |
3872 // | RESTSubReq2 | | |
3873 // |---------------->| | |
3875 // | RESTSubResp2 | | |
3876 // |<----------------| | |
3878 // | |---------------------------->|
3881 // | |<-------------| |
3882 // | RESTNotif1 | | |
3883 // |<----------------| | |
3885 // | |<----------------------------|
3886 // | RESTNotif2 | | |
3887 // |<----------------| | |
3889 // | [SUBS 1 DELETE] | |
3891 // | [SUBS 2 DELETE] | |
3894 //-----------------------------------------------------------------------------
3895 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
3896 CaseBegin("TestRESTSubReqAndSubDelOkTwoE2termParallel")
3898 // Init counter check
3899 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3900 Counter{cRestSubReqFromXapp, 2},
3901 Counter{cSubReqToE2, 2},
3902 Counter{cSubRespFromE2, 2},
3903 Counter{cRestSubRespToXapp, 2},
3904 Counter{cRestSubDelReqFromXapp, 2},
3905 Counter{cSubDelReqToE2, 2},
3906 Counter{cSubDelRespFromE2, 2},
3907 Counter{cRestSubDelRespToXapp, 2},
3910 const subReqCount int = 1
3913 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3914 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3915 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3918 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3919 params.SetMeid("RAN_NAME_11")
3920 // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
3921 // would not work as notification would not be received
3922 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3923 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
3926 xappConn1.ExpectRESTNotification(t, restSubId1)
3927 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3928 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
3929 xapp.Logger.Info("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
3932 xappConn2.ExpectRESTNotification(t, restSubId2)
3933 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
3934 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
3935 xapp.Logger.Info("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
3938 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3939 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3940 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3942 // Wait that subs is cleaned
3943 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3946 xappConn1.SendRESTSubsDelReq(t, &restSubId2)
3947 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
3948 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
3950 // Wait that subs is cleaned
3951 waitSubsCleanup(t, e2SubsId2, 10)
3953 mainCtrl.VerifyCounterValues(t)
3956 //-----------------------------------------------------------------------------
3957 // TestRESTSubReqAsn1EncodeFail
3959 // In this case submgr send RICSubscriptionDeleteRequest after encode failure which should not happen!
3961 // +-------+ +---------+ +---------+
3962 // | xapp | | submgr | | e2term |
3963 // +-------+ +---------+ +---------+
3966 // |---------------->| |
3968 // | RESTSubResp | |
3969 // |<----------------| |
3970 // | RESTSubDelReq | |
3971 // |---------------->| |
3972 // | RESTSubDelResp | |
3974 // |<----------------| |
3977 //-----------------------------------------------------------------------------
3978 func TestRESTSubReqAsn1EncodeFail(t *testing.T) {
3979 CaseBegin("TestRESTSubReqAsn1EncodeFail")
3981 xapp.Logger.Info("Xapp-frame, v0.8.1 sufficient REST API validation")
3985 //-----------------------------------------------------------------------------
3986 // TestRESTSubReqInsertAndSubDelOk
3989 // +-------+ +---------+ +---------+
3990 // | xapp | | submgr | | e2term |
3991 // +-------+ +---------+ +---------+
3994 // |---------------->| |
3996 // | RESTSubResp | |
3997 // |<----------------| |
4000 // | |------------->|
4003 // | |<-------------|
4005 // |<----------------| |
4008 // | RESTSubDelReq | |
4009 // |---------------->| |
4012 // | |------------->|
4015 // | |<-------------|
4017 // | RESTSubDelResp| |
4018 // |<----------------| |
4020 //-----------------------------------------------------------------------------
4021 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
4022 CaseBegin("TestRESTInsertSubReqAndSubDelOk")
4024 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4025 Counter{cRestSubReqFromXapp, 1},
4026 Counter{cSubReqToE2, 1},
4027 Counter{cSubRespFromE2, 1},
4028 Counter{cRestSubRespToXapp, 1},
4029 Counter{cRestSubDelReqFromXapp, 1},
4030 Counter{cSubDelReqToE2, 1},
4031 Counter{cSubDelRespFromE2, 1},
4032 Counter{cRestSubDelRespToXapp, 1},
4035 const subReqCount int = 1
4037 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4038 params.SetSubActionTypes("insert")
4041 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4044 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4046 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4047 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4049 // Wait that subs is cleaned
4050 waitSubsCleanup(t, e2SubsId, 10)
4051 mainCtrl.VerifyCounterValues(t)
4054 //-----------------------------------------------------------------------------
4055 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
4058 // +-------+ +---------+ +---------+
4059 // | xapp | | submgr | | e2term |
4060 // +-------+ +---------+ +---------+
4063 // |------------->| |
4066 // | |------------->|
4071 // | Submgr restart |
4075 // | |------------->|
4078 // | |<-------------|
4081 //-----------------------------------------------------------------------------
4082 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
4083 CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle")
4085 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4086 Counter{cRestSubReqFromXapp, 1},
4087 Counter{cSubReqToE2, 1},
4088 Counter{cSubDelReqFromXapp, 1},
4089 Counter{cSubDelReqToE2, 1},
4090 Counter{cSubDelRespFromE2, 1},
4093 const subReqCount int = 1
4095 // Remove possible existing subscription
4096 mainCtrl.removeExistingSubscriptions(t)
4098 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4101 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
4102 restSubId := xappConn1.SendRESTSubsReq(t, params)
4103 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
4105 e2termConn1.RecvSubsReq(t)
4107 mainCtrl.SetResetTestFlag(t, false)
4109 mainCtrl.SimulateRestart(t)
4110 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4113 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4114 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4116 xappConn1.TestMsgChanEmpty(t)
4117 xappConn2.TestMsgChanEmpty(t)
4118 e2termConn1.TestMsgChanEmpty(t)
4119 mainCtrl.wait_registry_empty(t, 10)
4121 mainCtrl.VerifyCounterValues(t)
4124 //-----------------------------------------------------------------------------
4125 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
4128 // +-------+ +---------+ +---------+
4129 // | xapp | | submgr | | e2term |
4130 // +-------+ +---------+ +---------+
4133 // |---------------->| |
4135 // | RESTSubResp | |
4136 // |<----------------| |
4138 // | |------------->|
4141 // | |<-------------|
4144 // |<----------------| |
4147 // | Submgr restart |
4149 // | RESTSubDelReq | |
4150 // |---------------->| |
4153 // | |------------->|
4156 // | |<-------------|
4158 // | RESTSubDelResp | |
4159 // |<----------------| |
4161 //-----------------------------------------------------------------------------
4162 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
4163 CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle")
4165 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4166 Counter{cRestSubReqFromXapp, 1},
4167 Counter{cSubReqToE2, 1},
4168 Counter{cSubRespFromE2, 1},
4169 Counter{cRestSubRespToXapp, 1},
4170 Counter{cRestSubDelReqFromXapp, 1},
4171 Counter{cSubDelReqToE2, 1},
4172 Counter{cRestSubDelRespToXapp, 1},
4175 // Remove possible existing subscription
4176 mainCtrl.removeExistingSubscriptions(t)
4178 var params *teststube2ap.RESTSubsReqParams = nil
4180 // Create subscription
4181 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4182 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
4184 // Check subscription
4185 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4187 // When SDL support for the REST Interface is added
4188 // the submgr restart statement below should be removed
4189 // from the comment.
4191 // mainCtrl.SimulateRestart(t)
4192 // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4194 // Check subscription
4195 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4197 // Delete subscription
4198 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
4200 //Wait that subs is cleaned
4201 waitSubsCleanup(t, e2SubsId, 10)
4203 mainCtrl.VerifyCounterValues(t)
4206 //-----------------------------------------------------------------------------
4207 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
4210 // +-------+ +-------+ +---------+ +---------+
4211 // | xapp2 | | xapp1 | | submgr | | e2term |
4212 // +-------+ +-------+ +---------+ +---------+
4214 // | | RESTSubReq1 | |
4215 // | |---------------->| |
4217 // | | RESTSubResp1 | |
4218 // | |<----------------| |
4221 // | | |------------->|
4223 // | | |<-------------|
4224 // | | RESTNotif1 | |
4225 // | |<----------------| |
4227 // | RESTSubReq2 | |
4228 // |------------------------------>| |
4230 // | RESTSubResp2 | |
4231 // |<------------------------------| |
4233 // | | RESTNotif2 | |
4234 // |<------------------------------| |
4236 // | | Submgr restart |
4238 // | | RESTSubDelReq1 | |
4239 // | |---------------->| |
4241 // | | RESTSubDelResp1 | |
4242 // | |<----------------| |
4244 // | | Submgr restart |
4246 // | RESTSubDelReq2 | |
4247 // |------------------------------>| |
4249 // | RESTSubDelResp2 | |
4250 // |<------------------------------| |
4252 // | | | SubDelReq2 |
4253 // | | |------------->|
4255 // | | | SubDelResp2 |
4256 // | | |<-------------|
4259 //-----------------------------------------------------------------------------
4260 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
4261 CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
4263 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4264 Counter{cRestSubReqFromXapp, 2},
4265 Counter{cSubReqToE2, 1},
4266 Counter{cSubRespFromE2, 1},
4267 Counter{cRestSubRespToXapp, 2},
4268 Counter{cMergedSubscriptions, 1},
4269 Counter{cUnmergedSubscriptions, 1},
4270 Counter{cRestSubDelReqFromXapp, 2},
4271 Counter{cSubDelReqToE2, 1},
4272 Counter{cSubDelRespFromE2, 1},
4273 Counter{cRestSubDelRespToXapp, 2},
4276 // Remove possible existing subscription
4277 mainCtrl.removeExistingSubscriptions(t)
4279 var params *teststube2ap.RESTSubsReqParams = nil
4281 // Create subscription 1
4282 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4283 xapp.Logger.Info("Send REST subscriber request for subscriber 1 : %v", restSubId1)
4285 // Create subscription 2 with same action
4286 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4287 params.SetMeid("RAN_NAME_1")
4288 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4289 xappConn2.WaitRESTNotificationForAnySubscriptionId(t)
4290 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4291 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4292 e2SubsId2 := <-xappConn2.RESTNotification
4293 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
4295 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
4297 // When SDL support for the REST Interface is added
4298 // the submgr restart statement below should be removed
4299 // from the comment.
4301 // mainCtrl.SimulateRestart(t)
4302 // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4304 // Delete subscription 1, and wait until it has removed the first endpoint
4305 subepcnt := mainCtrl.get_subs_entrypoint_cnt(t, e2SubsId1)
4306 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4307 mainCtrl.wait_subs_entrypoint_cnt_change(t, e2SubsId1, subepcnt, 10)
4309 // When SDL support for the REST Interface is added
4310 // the submgr restart statement below should be removed
4311 // from the comment.
4313 // mainCtrl.SimulateRestart(t)
4314 // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4315 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
4317 // Delete subscription 2
4318 deleteXapp2Subscription(t, &restSubId2)
4320 //Wait that subs is cleaned
4321 waitSubsCleanup(t, e2SubsId2, 10)
4323 mainCtrl.VerifyCounterValues(t)
4326 //-----------------------------------------------------------------------------
4327 // TestRESTReportSubReqAndSubDelOk
4330 // +-------+ +---------+ +---------+
4331 // | xapp | | submgr | | e2term |
4332 // +-------+ +---------+ +---------+
4335 // |---------------->| |
4337 // | RESTSubResp | |
4338 // |<----------------| |
4341 // | |------------->|
4344 // | |<-------------|
4346 // |<----------------| |
4348 // | |------------->|
4351 // | |<-------------|
4353 // |<----------------| |
4357 // | RESTSubDelReq | |
4358 // |---------------->| |
4361 // | |------------->|
4364 // | |<-------------|
4366 // | RESTSubDelResp| |
4367 // |<----------------| |
4369 //-----------------------------------------------------------------------------
4370 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
4371 CaseBegin("TestRESTReportSubReqAndSubDelOk")
4374 RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
4377 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
4378 xapp.Logger.Info("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
4381 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4382 restSubId := xappConn1.SendRESTSubsReq(t, params)
4384 var e2SubsId []uint32
4385 for i := 0; i < subReqCount; i++ {
4386 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4387 xappConn1.ExpectRESTNotification(t, restSubId)
4389 e2termConn1.SendSubsResp(t, crereq, cremsg)
4390 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
4391 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
4392 e2SubsId = append(e2SubsId, instanceId)
4393 resp, _ := xapp.Subscription.QuerySubscriptions()
4394 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
4395 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
4396 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
4401 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4403 for i := 0; i < subReqCount; i++ {
4404 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4405 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4408 // Wait that subs is cleaned
4409 for i := 0; i < subReqCount; i++ {
4410 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
4413 xappConn1.TestMsgChanEmpty(t)
4414 e2termConn1.TestMsgChanEmpty(t)
4415 mainCtrl.wait_registry_empty(t, 10)
4419 func TestRESTPolicySubReqAndSubDelOk(t *testing.T) {
4420 CaseBegin("TestRESTPolicySubReqAndSubDelOk")
4424 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
4428 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
4431 func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
4432 xapp.Logger.Info("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
4435 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4436 restSubId := xappConn1.SendRESTSubsReq(t, params)
4437 //params := xappConn1.GetRESTSubsReqPolicyParams1(subReqCount)
4438 //restSubId := xappConn1.SendRESTPolicySubsReq(t, params)
4440 var e2SubsId []uint32
4441 for i := 0; i < subReqCount; i++ {
4442 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4443 xappConn1.ExpectRESTNotification(t, restSubId)
4444 e2termConn1.SendSubsResp(t, crereq, cremsg)
4445 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
4446 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
4447 e2SubsId = append(e2SubsId, instanceId)
4451 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4453 for i := 0; i < subReqCount; i++ {
4454 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4455 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4458 // Wait that subs is cleaned
4459 for i := 0; i < subReqCount; i++ {
4460 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
4462 xappConn1.TestMsgChanEmpty(t)
4463 e2termConn1.TestMsgChanEmpty(t)
4464 mainCtrl.wait_registry_empty(t, 10)
4467 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
4471 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4472 Counter{cRestSubReqFromXapp, 1},
4473 Counter{cSubReqToE2, 2},
4474 Counter{cSubRespFromE2, 2},
4475 Counter{cRestSubRespToXapp, 2},
4476 Counter{cRestSubDelReqFromXapp, 1},
4477 Counter{cSubDelReqToE2, 2},
4478 Counter{cSubDelRespFromE2, 2},
4479 Counter{cRestSubDelRespToXapp, 1},
4483 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4484 restSubId := xappConn1.SendRESTSubsReq(t, params)
4485 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4487 assert.Equal(t, len(e2SubsIds), 2)
4490 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4491 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4493 xappConn1.TestMsgChanEmpty(t)
4494 e2termConn1.TestMsgChanEmpty(t)
4495 mainCtrl.wait_registry_empty(t, 10)
4497 mainCtrl.VerifyCounterValues(t)
4499 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
4503 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4504 Counter{cRestSubReqFromXapp, 1},
4505 Counter{cSubReqToE2, 19},
4506 Counter{cSubRespFromE2, 19},
4507 Counter{cRestSubRespToXapp, 19},
4508 Counter{cRestSubDelReqFromXapp, 1},
4509 Counter{cSubDelReqToE2, 19},
4510 Counter{cSubDelRespFromE2, 19},
4511 Counter{cRestSubDelRespToXapp, 1},
4515 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4516 restSubId := xappConn1.SendRESTSubsReq(t, params)
4517 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4519 assert.Equal(t, len(e2SubsIds), 19)
4521 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4522 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4524 xappConn1.TestMsgChanEmpty(t)
4525 e2termConn1.TestMsgChanEmpty(t)
4526 mainCtrl.wait_registry_empty(t, 10)
4528 mainCtrl.VerifyCounterValues(t)
4530 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
4534 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4535 Counter{cRestSubReqFromXapp, 1},
4536 Counter{cSubReqToE2, uint64(subReqCount)},
4537 Counter{cSubRespFromE2, uint64(subReqCount)},
4538 Counter{cRestSubRespToXapp, uint64(subReqCount)},
4539 Counter{cRestSubDelReqFromXapp, 1},
4540 Counter{cSubDelReqToE2, uint64(subReqCount)},
4541 Counter{cSubDelRespFromE2, uint64(subReqCount)},
4542 Counter{cRestSubDelRespToXapp, 1},
4546 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4547 restSubId := xappConn1.SendRESTSubsReq(t, params)
4548 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4550 assert.Equal(t, len(e2SubsIds), subReqCount)
4553 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4554 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4556 xappConn1.TestMsgChanEmpty(t)
4557 e2termConn1.TestMsgChanEmpty(t)
4558 mainCtrl.wait_registry_empty(t, 10)
4560 mainCtrl.VerifyCounterValues(t)
4563 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
4567 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4568 Counter{cRestSubReqFromXapp, 1},
4569 Counter{cSubReqToE2, uint64(subReqCount)},
4570 Counter{cSubRespFromE2, uint64(subReqCount)},
4571 Counter{cRestSubRespToXapp, uint64(subReqCount)},
4572 Counter{cRestSubDelReqFromXapp, 1},
4573 Counter{cSubDelReqToE2, uint64(subReqCount)},
4574 Counter{cSubDelRespFromE2, uint64(subReqCount)},
4575 Counter{cRestSubDelRespToXapp, 1},
4579 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4580 restSubId := xappConn1.SendRESTSubsReq(t, params)
4581 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4583 assert.Equal(t, len(e2SubsIds), subReqCount)
4586 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4587 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4589 xappConn1.TestMsgChanEmpty(t)
4590 e2termConn1.TestMsgChanEmpty(t)
4591 mainCtrl.wait_registry_empty(t, 10)
4593 mainCtrl.VerifyCounterValues(t)
4596 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
4600 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4601 Counter{cRestSubReqFromXapp, 1},
4602 Counter{cSubReqToE2, uint64(subReqCount)},
4603 Counter{cSubRespFromE2, uint64(subReqCount)},
4604 Counter{cRestSubRespToXapp, uint64(subReqCount)},
4605 Counter{cRestSubDelReqFromXapp, 1},
4606 Counter{cSubDelReqToE2, uint64(subReqCount)},
4607 Counter{cSubDelRespFromE2, uint64(subReqCount)},
4608 Counter{cRestSubDelRespToXapp, 1},
4612 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4613 restSubId := xappConn1.SendRESTSubsReq(t, params)
4614 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4616 assert.Equal(t, len(e2SubsIds), subReqCount)
4619 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4620 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4622 xappConn1.TestMsgChanEmpty(t)
4623 e2termConn1.TestMsgChanEmpty(t)
4624 mainCtrl.wait_registry_empty(t, 10)
4626 mainCtrl.VerifyCounterValues(t)
4629 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
4630 CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
4632 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4633 Counter{cRestSubReqFromXapp, 2},
4634 Counter{cSubReqToE2, 2},
4635 Counter{cSubRespFromE2, 2},
4636 Counter{cRestSubRespToXapp, 2},
4637 Counter{cRestSubDelReqFromXapp, 2},
4638 Counter{cSubDelReqToE2, 2},
4639 Counter{cSubDelRespFromE2, 2},
4640 Counter{cRestSubDelRespToXapp, 2},
4644 var params *teststube2ap.RESTSubsReqParams = nil
4647 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4648 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4650 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4653 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4654 params.SetMeid("RAN_NAME_1")
4655 eventTriggerDefinition := "1234"
4656 params.SetSubEventTriggerDefinition(eventTriggerDefinition)
4658 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4659 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4660 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4661 xappConn2.ExpectRESTNotification(t, restSubId2)
4662 e2termConn1.SendSubsResp(t, crereq, cremsg)
4663 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4665 deleteXapp1Subscription(t, &restSubId1)
4666 deleteXapp2Subscription(t, &restSubId2)
4668 waitSubsCleanup(t, e2SubsId1, 10)
4669 waitSubsCleanup(t, e2SubsId2, 10)
4671 mainCtrl.VerifyCounterValues(t)
4675 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
4676 CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
4678 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4679 Counter{cRestSubReqFromXapp, 2},
4680 Counter{cSubReqToE2, 2},
4681 Counter{cSubRespFromE2, 2},
4682 Counter{cRestSubRespToXapp, 2},
4683 Counter{cRestSubDelReqFromXapp, 2},
4684 Counter{cSubDelReqToE2, 2},
4685 Counter{cSubDelRespFromE2, 2},
4686 Counter{cRestSubDelRespToXapp, 2},
4690 var params *teststube2ap.RESTSubsReqParams = nil
4693 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4694 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4696 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4699 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4700 params.SetMeid("RAN_NAME_1")
4702 actionId := int64(1)
4703 actionType := "report"
4704 actionDefinition := "56781"
4705 subsequestActionType := "continue"
4706 timeToWait := "w10ms"
4707 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
4709 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4710 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4711 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4712 xappConn2.ExpectRESTNotification(t, restSubId2)
4713 e2termConn1.SendSubsResp(t, crereq, cremsg)
4714 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4716 deleteXapp1Subscription(t, &restSubId1)
4717 deleteXapp2Subscription(t, &restSubId2)
4719 waitSubsCleanup(t, e2SubsId1, 10)
4720 waitSubsCleanup(t, e2SubsId2, 10)
4722 mainCtrl.VerifyCounterValues(t)
4726 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
4727 CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
4729 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4730 Counter{cRestSubReqFromXapp, 2},
4731 Counter{cSubReqToE2, 2},
4732 Counter{cSubRespFromE2, 2},
4733 Counter{cRestSubRespToXapp, 2},
4734 Counter{cRestSubDelReqFromXapp, 2},
4735 Counter{cSubDelReqToE2, 2},
4736 Counter{cSubDelRespFromE2, 2},
4737 Counter{cRestSubDelRespToXapp, 2},
4741 var params *teststube2ap.RESTSubsReqParams = nil
4744 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4745 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4747 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4750 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4751 params.SetMeid("RAN_NAME_1")
4752 params.SetSubActionIDs(int64(2))
4754 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4755 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4756 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4757 xappConn2.ExpectRESTNotification(t, restSubId2)
4758 e2termConn1.SendSubsResp(t, crereq, cremsg)
4759 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4761 deleteXapp1Subscription(t, &restSubId1)
4762 deleteXapp2Subscription(t, &restSubId2)
4764 waitSubsCleanup(t, e2SubsId1, 10)
4765 waitSubsCleanup(t, e2SubsId2, 10)
4767 mainCtrl.VerifyCounterValues(t)
4771 func TestRESTSubReqDiffActionType(t *testing.T) {
4772 CaseBegin("TestRESTSubReqDiffActionType")
4774 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4775 Counter{cRestSubReqFromXapp, 2},
4776 Counter{cSubReqToE2, 2},
4777 Counter{cSubRespFromE2, 2},
4778 Counter{cRestSubRespToXapp, 2},
4779 Counter{cRestSubDelReqFromXapp, 2},
4780 Counter{cSubDelReqToE2, 2},
4781 Counter{cSubDelRespFromE2, 2},
4782 Counter{cRestSubDelRespToXapp, 2},
4786 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4789 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4790 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4792 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4795 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4796 params.SetMeid("RAN_NAME_1")
4798 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4799 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4800 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4801 xappConn2.ExpectRESTNotification(t, restSubId2)
4802 e2termConn1.SendSubsResp(t, crereq, cremsg)
4803 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4805 deleteXapp1Subscription(t, &restSubId1)
4806 deleteXapp2Subscription(t, &restSubId2)
4808 waitSubsCleanup(t, e2SubsId1, 10)
4809 waitSubsCleanup(t, e2SubsId2, 10)
4811 mainCtrl.VerifyCounterValues(t)
4815 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
4816 CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
4818 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4819 Counter{cRestSubReqFromXapp, 2},
4820 Counter{cSubReqToE2, 2},
4821 Counter{cSubRespFromE2, 2},
4822 Counter{cRestSubRespToXapp, 2},
4823 Counter{cRestSubDelReqFromXapp, 2},
4824 Counter{cSubDelReqToE2, 2},
4825 Counter{cSubDelRespFromE2, 2},
4826 Counter{cRestSubDelRespToXapp, 2},
4830 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4833 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4834 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4836 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4839 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
4840 params.SetMeid("RAN_NAME_1")
4842 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4843 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4844 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4845 xappConn2.ExpectRESTNotification(t, restSubId2)
4846 e2termConn1.SendSubsResp(t, crereq, cremsg)
4847 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4849 deleteXapp1Subscription(t, &restSubId1)
4850 deleteXapp2Subscription(t, &restSubId2)
4852 waitSubsCleanup(t, e2SubsId1, 10)
4853 waitSubsCleanup(t, e2SubsId2, 10)
4855 mainCtrl.VerifyCounterValues(t)
4859 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
4860 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
4862 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4863 Counter{cRestSubReqFromXapp, 2},
4864 Counter{cSubReqToE2, 2},
4865 Counter{cSubRespFromE2, 2},
4866 Counter{cRestSubRespToXapp, 2},
4867 Counter{cRestSubDelReqFromXapp, 2},
4868 Counter{cSubDelReqToE2, 2},
4869 Counter{cSubDelRespFromE2, 2},
4870 Counter{cRestSubDelRespToXapp, 2},
4874 var params *teststube2ap.RESTSubsReqParams = nil
4877 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4878 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4880 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4883 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4884 params.SetMeid("RAN_NAME_1")
4885 actionDefinition := "5678"
4886 params.SetSubActionDefinition(actionDefinition)
4888 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4889 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4890 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4891 xappConn2.ExpectRESTNotification(t, restSubId2)
4892 e2termConn1.SendSubsResp(t, crereq, cremsg)
4893 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4895 deleteXapp1Subscription(t, &restSubId1)
4896 deleteXapp2Subscription(t, &restSubId2)
4898 waitSubsCleanup(t, e2SubsId1, 10)
4899 waitSubsCleanup(t, e2SubsId2, 10)
4901 mainCtrl.VerifyCounterValues(t)
4905 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
4906 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
4908 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4909 Counter{cRestSubReqFromXapp, 2},
4910 Counter{cSubReqToE2, 2},
4911 Counter{cSubRespFromE2, 2},
4912 Counter{cRestSubRespToXapp, 2},
4913 Counter{cRestSubDelReqFromXapp, 2},
4914 Counter{cSubDelReqToE2, 2},
4915 Counter{cSubDelRespFromE2, 2},
4916 Counter{cRestSubDelRespToXapp, 2},
4920 var params *teststube2ap.RESTSubsReqParams = nil
4923 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4924 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4926 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4929 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4930 params.SetMeid("RAN_NAME_1")
4931 actionDefinition := "56782"
4932 params.SetSubActionDefinition(actionDefinition)
4934 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4935 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4936 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4937 xappConn2.ExpectRESTNotification(t, restSubId2)
4938 e2termConn1.SendSubsResp(t, crereq, cremsg)
4939 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4941 deleteXapp1Subscription(t, &restSubId1)
4942 deleteXapp2Subscription(t, &restSubId2)
4944 waitSubsCleanup(t, e2SubsId1, 10)
4945 waitSubsCleanup(t, e2SubsId2, 10)
4947 mainCtrl.VerifyCounterValues(t)
4951 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
4952 CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
4954 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4955 Counter{cRestSubReqFromXapp, 2},
4956 Counter{cSubReqToE2, 2},
4957 Counter{cSubRespFromE2, 2},
4958 Counter{cRestSubRespToXapp, 2},
4959 Counter{cRestSubDelReqFromXapp, 2},
4960 Counter{cSubDelReqToE2, 2},
4961 Counter{cSubDelRespFromE2, 2},
4962 Counter{cRestSubDelRespToXapp, 2},
4966 var params *teststube2ap.RESTSubsReqParams = nil
4969 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4970 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4972 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4975 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4976 params.SetMeid("RAN_NAME_1")
4977 params.SetTimeToWait("w200ms")
4978 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4979 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4980 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4981 xappConn2.ExpectRESTNotification(t, restSubId2)
4982 e2termConn1.SendSubsResp(t, crereq, cremsg)
4983 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4985 deleteXapp1Subscription(t, &restSubId1)
4986 deleteXapp2Subscription(t, &restSubId2)
4988 waitSubsCleanup(t, e2SubsId1, 10)
4989 waitSubsCleanup(t, e2SubsId2, 10)
4991 mainCtrl.VerifyCounterValues(t)
4995 //-----------------------------------------------------------------------------
4996 // TestRESTUnpackSubscriptionResponseDecodeFail
4999 // +-------+ +---------+ +---------+
5000 // | xapp | | submgr | | e2term |
5001 // +-------+ +---------+ +---------+
5004 // |---------------->| |
5006 // | RESTSubResp | |
5007 // |<----------------| |
5010 // | |------------->|
5012 // | | SubResp | ASN.1 decode fails
5013 // | |<-------------|
5016 // | |------------->|
5018 // | | SubFail | Duplicated action
5019 // | |<-------------|
5020 // | RESTNotif (fail)| |
5021 // |<----------------| |
5023 // | |------------->|
5026 // | |<-------------|
5028 //-----------------------------------------------------------------------------
5029 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
5030 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
5034 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5035 restSubId := xappConn1.SendRESTSubsReq(t, params)
5037 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5038 // Decode of this response fails which will result resending original request
5039 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
5041 _, cremsg = e2termConn1.RecvSubsReq(t)
5043 xappConn1.ExpectRESTNotification(t, restSubId)
5045 // Subscription already created in E2 Node.
5046 fparams := &teststube2ap.E2StubSubsFailParams{}
5048 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5049 e2termConn1.SendSubsFail(t, fparams, cremsg)
5051 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5052 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5054 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5055 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5057 // Wait that subs is cleaned
5058 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5060 xappConn1.TestMsgChanEmpty(t)
5061 e2termConn1.TestMsgChanEmpty(t)
5062 mainCtrl.wait_registry_empty(t, 10)
5065 //-----------------------------------------------------------------------------
5066 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
5069 // +-------+ +---------+ +---------+
5070 // | xapp | | submgr | | e2term |
5071 // +-------+ +---------+ +---------+
5074 // |---------------->| |
5076 // | RESTSubResp | |
5077 // |<----------------| |
5080 // | |------------->|
5082 // | | SubResp | Unknown instanceId
5083 // | |<-------------|
5086 // | |------------->|
5088 // | | SubFail | Duplicated action
5089 // | |<-------------|
5090 // | RESTNotif (fail)| |
5091 // |<----------------| |
5093 // | |------------->|
5096 // | |<-------------|
5098 //-----------------------------------------------------------------------------
5099 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
5100 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
5104 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5105 restSubId := xappConn1.SendRESTSubsReq(t, params)
5107 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5109 // Unknown instanceId in this response which will result resending original request
5110 orgInstanceId := crereq.RequestId.InstanceId
5111 crereq.RequestId.InstanceId = 0
5112 e2termConn1.SendSubsResp(t, crereq, cremsg)
5114 _, cremsg = e2termConn1.RecvSubsReq(t)
5116 xappConn1.ExpectRESTNotification(t, restSubId)
5118 // Subscription already created in E2 Node.
5119 fparams := &teststube2ap.E2StubSubsFailParams{}
5121 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5122 e2termConn1.SendSubsFail(t, fparams, cremsg)
5124 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5125 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5127 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5128 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5130 // Wait that subs is cleaned
5131 mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
5133 xappConn1.TestMsgChanEmpty(t)
5134 e2termConn1.TestMsgChanEmpty(t)
5135 mainCtrl.wait_registry_empty(t, 10)
5138 //-----------------------------------------------------------------------------
5139 // TestRESTUnpackSubscriptionResponseNoTransaction
5142 // +-------+ +---------+ +---------+
5143 // | xapp | | submgr | | e2term |
5144 // +-------+ +---------+ +---------+
5147 // |---------------->| |
5149 // | RESTSubResp | |
5150 // |<----------------| |
5153 // | |------------->|
5155 // | | SubResp | No transaction for the response
5156 // | |<-------------|
5159 // | |------------->|
5161 // | | SubFail | Duplicated action
5162 // | |<-------------|
5163 // | RESTNotif (fail)| |
5164 // |<----------------| |
5166 // | |------------->|
5169 // | |<-------------|
5172 // | |------------->|
5175 // | |<-------------|
5177 //-----------------------------------------------------------------------------
5178 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
5179 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
5183 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5184 restSubId := xappConn1.SendRESTSubsReq(t, params)
5186 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5188 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
5189 // No transaction exist for this response which will result resending original request
5190 e2termConn1.SendSubsResp(t, crereq, cremsg)
5192 _, cremsg = e2termConn1.RecvSubsReq(t)
5194 xappConn1.ExpectRESTNotification(t, restSubId)
5196 // Subscription already created in E2 Node.
5197 fparams := &teststube2ap.E2StubSubsFailParams{}
5199 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5200 e2termConn1.SendSubsFail(t, fparams, cremsg)
5202 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5203 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5205 // Resending happens because there no transaction
5206 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5207 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5209 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5210 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5212 // Wait that subs is cleaned
5213 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5215 xappConn1.TestMsgChanEmpty(t)
5216 e2termConn1.TestMsgChanEmpty(t)
5217 mainCtrl.wait_registry_empty(t, 10)
5221 //-----------------------------------------------------------------------------
5222 // TestRESTUnpackSubscriptionFailureDecodeFail
5225 // +-------+ +---------+ +---------+
5226 // | xapp | | submgr | | e2term |
5227 // +-------+ +---------+ +---------+
5230 // |---------------->| |
5232 // | RESTSubResp | |
5233 // |<----------------| |
5236 // | |------------->|
5238 // | | SubFail | ASN.1 decode fails
5239 // | |<-------------|
5242 // | |------------->|
5244 // | | SubFail | Duplicated action
5245 // | |<-------------|
5246 // | RESTNotif (fail)| |
5247 // |<----------------| |
5249 // | |------------->|
5252 // | |<-------------|
5254 //-----------------------------------------------------------------------------
5255 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
5256 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
5260 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5261 restSubId := xappConn1.SendRESTSubsReq(t, params)
5263 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5265 // Decode of this response fails which will result resending original request
5266 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
5268 _, cremsg = e2termConn1.RecvSubsReq(t)
5270 xappConn1.ExpectRESTNotification(t, restSubId)
5272 // Subscription already created in E2 Node.
5273 fparams := &teststube2ap.E2StubSubsFailParams{}
5275 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5276 e2termConn1.SendSubsFail(t, fparams, cremsg)
5278 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5279 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5281 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5282 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5284 // Wait that subs is cleaned
5285 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5287 xappConn1.TestMsgChanEmpty(t)
5288 e2termConn1.TestMsgChanEmpty(t)
5289 mainCtrl.wait_registry_empty(t, 10)
5292 //-----------------------------------------------------------------------------
5293 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
5296 // +-------+ +---------+ +---------+
5297 // | xapp | | submgr | | e2term |
5298 // +-------+ +---------+ +---------+
5301 // |---------------->| |
5303 // | RESTSubResp | |
5304 // |<----------------| |
5307 // | |------------->|
5309 // | | SubFail | Unknown instanceId
5310 // | |<-------------|
5313 // | |------------->|
5315 // | | SubFail | Duplicated action
5316 // | |<-------------|
5317 // | RESTNotif (fail)| |
5318 // |<----------------| |
5320 // | |------------->|
5323 // | |<-------------|
5325 //-----------------------------------------------------------------------------
5326 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
5327 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
5331 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5332 restSubId := xappConn1.SendRESTSubsReq(t, params)
5334 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5336 // Unknown instanceId in this response which will result resending original request
5337 fparams := &teststube2ap.E2StubSubsFailParams{}
5339 fparams.Fail.RequestId.InstanceId = 0
5340 e2termConn1.SendSubsFail(t, fparams, cremsg)
5342 _, cremsg = e2termConn1.RecvSubsReq(t)
5344 xappConn1.ExpectRESTNotification(t, restSubId)
5346 // Subscription already created in E2 Node.
5347 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5348 e2termConn1.SendSubsFail(t, fparams, cremsg)
5350 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5351 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5353 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5354 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5356 // Wait that subs is cleaned
5357 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5359 xappConn1.TestMsgChanEmpty(t)
5360 e2termConn1.TestMsgChanEmpty(t)
5361 mainCtrl.wait_registry_empty(t, 10)
5364 //-----------------------------------------------------------------------------
5365 // TestRESTUnpackSubscriptionFailureNoTransaction
5368 // +-------+ +---------+ +---------+
5369 // | xapp | | submgr | | e2term |
5370 // +-------+ +---------+ +---------+
5373 // |---------------->| |
5375 // | RESTSubResp | |
5376 // |<----------------| |
5379 // | |------------->|
5381 // | | SubFail | No transaction for the response
5382 // | |<-------------|
5385 // | |------------->|
5387 // | | SubFail | Duplicated action
5388 // | |<-------------|
5389 // | RESTNotif (fail)| |
5390 // |<----------------| |
5392 // | |------------->|
5395 // | |<-------------|
5397 //-----------------------------------------------------------------------------
5398 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
5399 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
5403 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5404 restSubId := xappConn1.SendRESTSubsReq(t, params)
5406 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5408 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
5410 // No transaction exist for this response which will result resending original request
5411 fparams := &teststube2ap.E2StubSubsFailParams{}
5413 e2termConn1.SendSubsFail(t, fparams, cremsg)
5415 _, cremsg = e2termConn1.RecvSubsReq(t)
5417 xappConn1.ExpectRESTNotification(t, restSubId)
5419 // Subscription already created in E2 Node.
5420 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5421 e2termConn1.SendSubsFail(t, fparams, cremsg)
5423 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5424 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5426 // Resending happens because there no transaction
5427 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5428 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5430 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5431 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5433 // Wait that subs is cleaned
5434 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5436 xappConn1.TestMsgChanEmpty(t)
5437 e2termConn1.TestMsgChanEmpty(t)
5438 mainCtrl.wait_registry_empty(t, 10)
5441 //-----------------------------------------------------------------------------
5442 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
5445 // +-------+ +---------+ +---------+
5446 // | xapp | | submgr | | e2term |
5447 // +-------+ +---------+ +---------+
5449 // | [SUBS CREATE] |
5452 // | RESTSubDelReq | |
5453 // |---------------->| |
5455 // | RESTSubDelResp | |
5456 // |<----------------| |
5459 // | |------------->|
5461 // | | SubDelResp | ASN.1 decode fails
5462 // | |<-------------|
5465 // | |------------->|
5467 // | | SubDelFail | Subscription does exist any more
5468 // | |<-------------|
5471 //-----------------------------------------------------------------------------
5472 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
5473 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail")
5476 var params *teststube2ap.RESTSubsReqParams = nil
5477 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5480 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5482 // E2t: Receive 1st SubsDelReq
5483 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5485 // Decode of this response fails which will result resending original request
5486 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_REQ)
5488 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
5489 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5491 // Subscription does not exist in in E2 Node.
5492 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5494 // Wait that subs is cleaned
5495 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5497 xappConn1.TestMsgChanEmpty(t)
5498 e2termConn1.TestMsgChanEmpty(t)
5499 mainCtrl.wait_registry_empty(t, 10)
5502 //-----------------------------------------------------------------------------
5503 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
5506 // +-------+ +---------+ +---------+
5507 // | xapp | | submgr | | e2term |
5508 // +-------+ +---------+ +---------+
5510 // | [SUBS CREATE] |
5513 // | RESTSubDelReq | |
5514 // |---------------->| |
5516 // | RESTSubDelResp | |
5517 // |<----------------| |
5520 // | |------------->|
5522 // | | SubDelResp | Unknown instanceId
5523 // | |<-------------|
5526 // | |------------->|
5528 // | | SubDelFail | Subscription does exist any more
5529 // | |<-------------|
5531 //-----------------------------------------------------------------------------
5532 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
5533 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId")
5536 var params *teststube2ap.RESTSubsReqParams = nil
5537 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5540 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5542 // E2t: Receive 1st SubsDelReq
5543 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5545 // Unknown instanceId in this response which will result resending original request
5546 delreq.RequestId.InstanceId = 0
5547 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5549 // E2t: Receive 2nd SubsDelReq
5550 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5552 // Subscription does not exist in in E2 Node.
5553 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5555 // Wait that subs is cleaned
5556 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5558 xappConn1.TestMsgChanEmpty(t)
5559 e2termConn1.TestMsgChanEmpty(t)
5560 mainCtrl.wait_registry_empty(t, 10)
5563 //-----------------------------------------------------------------------------
5564 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
5567 // +-------+ +---------+ +---------+
5568 // | xapp | | submgr | | e2term |
5569 // +-------+ +---------+ +---------+
5571 // | [SUBS CREATE] |
5574 // | RESTSubDelReq | |
5575 // |---------------->| |
5577 // | RESTSubDelResp | |
5578 // |<----------------| |
5581 // | |------------->|
5583 // | | SubDelResp | No transaction for the response
5584 // | |<-------------|
5587 // | |------------->|
5589 // | | SubDelFail | Subscription does exist any more
5590 // | |<-------------|
5592 //-----------------------------------------------------------------------------
5593 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
5594 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction")
5597 var params *teststube2ap.RESTSubsReqParams = nil
5598 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5601 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5603 // E2t: Receive 1st SubsDelReq
5604 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5606 mainCtrl.MakeTransactionNil(t, e2SubsId)
5608 // No transaction exist for this response which will result resending original request
5609 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5611 // E2t: Receive 2nd SubsDelReq
5612 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5614 // Subscription does not exist in in E2 Node.
5615 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5617 // Wait that subs is cleaned
5618 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5620 xappConn1.TestMsgChanEmpty(t)
5621 e2termConn1.TestMsgChanEmpty(t)
5622 mainCtrl.wait_registry_empty(t, 10)
5625 //-----------------------------------------------------------------------------
5626 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
5629 // +-------+ +---------+ +---------+
5630 // | xapp | | submgr | | e2term |
5631 // +-------+ +---------+ +---------+
5633 // | [SUBS CREATE] |
5636 // | RESTSubDelReq | |
5637 // |---------------->| |
5639 // | RESTSubDelResp | |
5640 // |<----------------| |
5643 // | |------------->|
5645 // | | SubDelFail | ASN.1 decode fails
5646 // | |<-------------|
5649 // | |------------->|
5651 // | | SubDelFail | Subscription does exist any more
5652 // | |<-------------|
5654 //-----------------------------------------------------------------------------
5655 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
5656 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail")
5659 var params *teststube2ap.RESTSubsReqParams = nil
5660 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5663 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5665 // E2t: Receive 1st SubsDelReq
5666 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5668 // Decode of this response fails which will result resending original request
5669 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
5671 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
5672 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5674 // Subscription does not exist in in E2 Node.
5675 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5677 // Wait that subs is cleaned
5678 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5680 xappConn1.TestMsgChanEmpty(t)
5681 e2termConn1.TestMsgChanEmpty(t)
5682 mainCtrl.wait_registry_empty(t, 10)
5685 //-----------------------------------------------------------------------------
5686 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
5689 // +-------+ +---------+ +---------+
5690 // | xapp | | submgr | | e2term |
5691 // +-------+ +---------+ +---------+
5693 // | [SUBS CREATE] |
5696 // | RESTSubDelReq | |
5697 // |---------------->| |
5699 // | RESTSubDelResp | |
5700 // |<----------------| |
5703 // | |------------->|
5705 // | | SubDelFail | Unknown instanceId
5706 // | |<-------------|
5709 // | |------------->|
5711 // | | SubDelFail | Subscription does exist any more
5712 // | |<-------------|
5714 //-----------------------------------------------------------------------------
5715 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
5716 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId")
5719 var params *teststube2ap.RESTSubsReqParams = nil
5720 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5723 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5725 // E2t: Receive 1st SubsDelReq
5726 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5728 // Unknown instanceId in this response which will result resending original request
5729 delreq.RequestId.InstanceId = 0
5730 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5732 // E2t: Receive 2nd SubsDelReq
5733 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5735 // Subscription does not exist in in E2 Node.
5736 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5738 // Wait that subs is cleaned
5739 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5741 xappConn1.TestMsgChanEmpty(t)
5742 e2termConn1.TestMsgChanEmpty(t)
5743 mainCtrl.wait_registry_empty(t, 10)
5746 //-----------------------------------------------------------------------------
5747 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
5750 // +-------+ +---------+ +---------+
5751 // | xapp | | submgr | | e2term |
5752 // +-------+ +---------+ +---------+
5754 // | [SUBS CREATE] |
5757 // | RESTSubDelReq | |
5758 // |---------------->| |
5760 // | RESTSubDelResp | |
5761 // |<----------------| |
5764 // | |------------->|
5766 // | | SubDelFail | No transaction for the response
5767 // | |<-------------|
5770 // | |------------->|
5772 // | | SubDelFail | Subscription does exist any more
5773 // | |<-------------|
5775 //-----------------------------------------------------------------------------
5776 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
5777 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction")
5780 var params *teststube2ap.RESTSubsReqParams = nil
5781 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5784 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5786 // E2t: Receive 1st SubsDelReq
5787 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5789 mainCtrl.MakeTransactionNil(t, e2SubsId)
5791 // No transaction exist for this response which will result resending original request
5792 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5794 // E2t: Receive 2nd SubsDelReq
5795 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5797 // Subscription does not exist in in E2 Node.
5798 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5800 // Wait that subs is cleaned
5801 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5803 xappConn1.TestMsgChanEmpty(t)
5804 e2termConn1.TestMsgChanEmpty(t)
5805 mainCtrl.wait_registry_empty(t, 10)
5808 //-----------------------------------------------------------------------------
5809 // TestRESTSubReqFailAsn1PackSubReqError
5812 // +-------+ +---------+ +---------+
5813 // | xapp | | submgr | | e2term |
5814 // +-------+ +---------+ +---------+
5817 // |---------------->| |
5819 // | RESTSubResp | |
5820 // |<----------------| |
5822 // | ASN.1 encode fails |
5825 // | |------------->|
5828 // | |<-------------|
5832 // |<----------------| |
5834 // | [SUBS DELETE] |
5837 //-----------------------------------------------------------------------------
5838 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
5840 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5841 Counter{cRestSubReqFromXapp, 1},
5842 Counter{cSubDelReqToE2, 1},
5843 Counter{cSubDelFailFromE2, 1},
5844 Counter{cRestSubRespToXapp, 1},
5849 var params *teststube2ap.RESTSubsReqParams = nil
5850 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
5851 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
5854 restSubId := xappConn1.SendRESTSubsReq(t, params)
5855 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
5857 // E2t: Receive SubsDelReq
5858 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5859 xappConn1.ExpectRESTNotification(t, restSubId)
5861 // Subscription does not exist in in E2 Node.
5862 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5864 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
5865 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
5867 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
5868 // Wait that subs is cleaned
5869 waitSubsCleanup(t, e2SubsId, 10)
5870 mainCtrl.VerifyCounterValues(t)
5873 ////////////////////////////////////////////////////////////////////////////////////
5874 // Services for UT cases
5875 ////////////////////////////////////////////////////////////////////////////////////
5876 const subReqCount int = 1
5877 const host string = "localhost"
5879 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
5881 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
5883 restSubId := fromXappConn.SendRESTSubsReq(t, params)
5884 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
5886 crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
5887 fromXappConn.ExpectRESTNotification(t, restSubId)
5888 toE2termConn.SendSubsResp(t, crereq1, cremsg1)
5889 e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
5890 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
5892 return restSubId, e2SubsId
5895 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
5897 params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
5899 params.SetMeid(meid)
5901 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
5902 restSubId := xappConn2.SendRESTSubsReq(t, params)
5903 xappConn2.ExpectRESTNotification(t, restSubId)
5904 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
5905 e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
5906 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
5908 return restSubId, e2SubsId
5911 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
5912 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5913 restSubId := xappConn1.SendRESTSubsReq(t, params)
5914 xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
5916 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
5917 xappConn1.ExpectRESTNotification(t, restSubId)
5918 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
5919 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
5920 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
5922 return restSubId, e2SubsId
5925 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
5926 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5927 restSubId := xappConn1.SendRESTSubsReq(t, params)
5929 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
5930 fparams1 := &teststube2ap.E2StubSubsFailParams{}
5931 fparams1.Set(crereq1)
5932 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
5934 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
5935 xappConn1.ExpectRESTNotification(t, restSubId)
5936 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
5937 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
5938 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
5940 return restSubId, e2SubsId
5943 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
5944 fromXappConn.SendRESTSubsDelReq(t, restSubId)
5945 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
5946 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
5949 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
5950 xappConn1.SendRESTSubsDelReq(t, restSubId)
5951 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5952 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5955 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
5956 xappConn2.SendRESTSubsDelReq(t, restSubId)
5957 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5958 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5961 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
5962 resp, _ := xapp.Subscription.QuerySubscriptions()
5963 assert.Equal(t, resp[0].SubscriptionID, e2SubsId)
5964 assert.Equal(t, resp[0].Meid, meid)
5965 assert.Equal(t, resp[0].ClientEndpoint, endpoint)
5968 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
5969 //Wait that subs is cleaned
5970 mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
5972 xappConn1.TestMsgChanEmpty(t)
5973 xappConn2.TestMsgChanEmpty(t)
5974 e2termConn1.TestMsgChanEmpty(t)
5975 mainCtrl.wait_registry_empty(t, timeout)
5978 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
5980 var e2SubsId []uint32
5982 for i := 0; i < count; i++ {
5983 xapp.Logger.Info("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
5984 crereq, cremsg := toE2termConn.RecvSubsReq(t)
5985 fromXappConn.ExpectRESTNotification(t, restSubId)
5986 toE2termConn.SendSubsResp(t, crereq, cremsg)
5987 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
5988 e2SubsId = append(e2SubsId, instanceId)
5989 xapp.Logger.Info("TEST: %v", e2SubsId)
5990 xapp.Logger.Info("TEST: %d ===================================== END CRE ============================================", i+1)
5991 <-time.After(100 * time.Millisecond)
5996 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
5998 for i := 0; i < len(e2SubsIds); i++ {
5999 xapp.Logger.Info("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
6000 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
6001 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
6002 <-time.After(1 * time.Second)
6003 xapp.Logger.Info("TEST: %d ===================================== END DEL ============================================", i+1)
6004 <-time.After(100 * time.Millisecond)
6007 // Wait that subs is cleaned
6008 for i := 0; i < len(e2SubsIds); i++ {
6009 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)