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 ==================================================================================
27 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
28 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper"
29 "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststube2ap"
30 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
31 "github.com/stretchr/testify/assert"
34 func TestSuiteSetup(t *testing.T) {
35 // The effect of this call shall endure thgough the UT suite!
36 // If this causes any issues, the previout interface can be restored
38 // SetPackerIf(e2ap_wrapper.NewAsn1E2APPacker())
40 SetPackerIf(e2ap_wrapper.NewUtAsn1E2APPacker())
42 restDuplicateCtrl.Init()
46 //-----------------------------------------------------------------------------
47 // TestRESTSubReqAndDeleteOkWithE2apUtWrapper
50 // +-------+ +---------+ +---------+ +---------+
51 // | xapp | | submgr | | e2term | | rtmgr |
52 // +-------+ +---------+ +---------+ +---------+
55 // |---------------->| | |
56 // | | RouteCreate | |
57 // | |--------------------------->| // The order of these events may vary
59 // | RESTSubResp | | | // The order of these events may vary
60 // |<----------------| | |
61 // | | RouteResponse| |
62 // | |<---------------------------| // The order of these events may vary
65 // | |------------->| | // The order of these events may vary
68 // | |<-------------| |
70 // |<----------------| | |
72 // | RESTSubDelReq | | |
73 // |---------------->| | |
75 // | |------------->| |
77 // | RESTSubDelResp| | |
78 // |<----------------| | |
81 // | |<-------------| |
85 //-----------------------------------------------------------------------------
86 func TestRESTSubReqAndDeleteOkWithE2apUtWrapper(t *testing.T) {
88 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
90 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
92 waitSubsCleanup(t, e2SubsId, 10)
95 //-----------------------------------------------------------------------------
96 // TestRESTSubReqAndE1apDeleteReqPackingError
99 // +-------+ +---------+ +---------+ +---------+
100 // | xapp | | submgr | | e2term | | rtmgr |
101 // +-------+ +---------+ +---------+ +---------+
103 // | RESTSubReq | | |
104 // |---------------->| | |
105 // | | RouteCreate | |
106 // | |--------------------------->| // The order of these events may vary
108 // | RESTSubResp | | | // The order of these events may vary
109 // |<----------------| | |
110 // | | RouteResponse| |
111 // | |<---------------------------| // The order of these events may vary
114 // | |------------->| | // The order of these events may vary
117 // | |<-------------| |
118 // | RESTNotif1 | | |
119 // |<----------------| | |
121 // | RESTSubDelReq | | |
122 // |---------------->| | |
124 // | RESTSubDelResp| | |
125 // |<----------------| | |
129 //-----------------------------------------------------------------------------
130 func TestRESTSubReqAndE1apDeleteReqPackingError(t *testing.T) {
132 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
134 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, false)
135 xappConn1.SendRESTSubsDelReq(t, &restSubId)
136 defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, true)
138 waitSubsCleanup(t, e2SubsId, 10)
141 //-----------------------------------------------------------------------------
142 // TestRESTSubReqAndE1apDeleteRespUnpackingError
145 // +-------+ +---------+ +---------+ +---------+
146 // | xapp | | submgr | | e2term | | rtmgr |
147 // +-------+ +---------+ +---------+ +---------+
149 // | RESTSubReq | | |
150 // |---------------->| | |
151 // | | RouteCreate | |
152 // | |--------------------------->| // The order of these events may vary
154 // | RESTSubResp | | | // The order of these events may vary
155 // |<----------------| | |
156 // | | RouteResponse| |
157 // | |<---------------------------| // The order of these events may vary
160 // | |------------->| | // The order of these events may vary
163 // | |<-------------| |
164 // | RESTNotif1 | | |
165 // |<----------------| | |
167 // | RESTSubDelReq | | |
168 // |---------------->| | |
170 // | |------------->| |
172 // | RESTSubDelResp| | |
173 // |<----------------| | | // The order of these events may vary
175 // | | SubDelResp | |
176 // | |<-------------| | // 1.st NOK
179 // | |------------->| |
181 // | | SubDelResp | |
182 // | |<-------------| | // 2.nd NOK
184 //-----------------------------------------------------------------------------
186 func TestRESTSubReqAndE1apDeleteRespUnpackingError(t *testing.T) {
188 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
190 xappConn1.SendRESTSubsDelReq(t, &restSubId)
191 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, false)
192 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
193 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
195 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
196 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
198 defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, true)
200 waitSubsCleanup(t, e2SubsId, 10)
203 //-----------------------------------------------------------------------------
204 // TestSubReqAndRouteNok
207 // +-------+ +---------+ +---------+
208 // | xapp | | submgr | | rtmgr |
209 // +-------+ +---------+ +---------+
212 // |------------->| |
215 // | |------------->|
219 // | |<-------------|
221 // | [SUBS INT DELETE] |
224 //-----------------------------------------------------------------------------
226 func TestSubReqAndRouteNok(t *testing.T) {
227 CaseBegin("TestSubReqAndRouteNok")
229 // Init counter check
230 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
231 Counter{cSubReqFromXapp, 1},
232 Counter{cRouteCreateFail, 1},
235 waiter := rtmgrHttp.AllocNextEvent(false)
236 newSubsId := mainCtrl.get_registry_next_subid(t)
237 xappConn1.SendSubsReq(t, nil, nil)
240 //Wait that subs is cleaned
241 mainCtrl.wait_subs_clean(t, newSubsId, 10)
243 xappConn1.TestMsgChanEmpty(t)
244 xappConn2.TestMsgChanEmpty(t)
245 e2termConn1.TestMsgChanEmpty(t)
246 mainCtrl.wait_registry_empty(t, 10)
248 <-time.After(1 * time.Second)
249 mainCtrl.VerifyCounterValues(t)
252 //-----------------------------------------------------------------------------
253 // TestSubReqAndRouteUpdateNok
256 // +-------+ +-------+ +---------+ +---------+
257 // | xapp2 | | xapp1 | | submgr | | rtmgr |
258 // +-------+ +-------+ +---------+ +---------+
260 // | [SUBS CREATE] | |
264 // | SubReq (mergeable) | |
265 // |--------------------------->| | |
267 // | | | RouteUpdate |
268 // | | |------------->|
270 // | | | RouteUpdate |
271 // | | | status:400 |
272 // | | |<-------------|
274 // | [SUBS INT DELETE] | |
277 // | [SUBS DELETE] | |
280 func TestSubReqAndRouteUpdateNok(t *testing.T) {
281 CaseBegin("TestSubReqAndRouteUpdateNok")
283 // Init counter check
284 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
285 Counter{cSubReqFromXapp, 2},
286 Counter{cSubReqToE2, 1},
287 Counter{cSubRespFromE2, 1},
288 Counter{cSubRespToXapp, 1},
289 Counter{cRouteCreateUpdateFail, 1},
290 Counter{cSubDelReqFromXapp, 1},
291 Counter{cSubDelReqToE2, 1},
292 Counter{cSubDelRespFromE2, 1},
293 Counter{cSubDelRespToXapp, 1},
296 cretrans := xappConn1.SendSubsReq(t, nil, nil)
297 crereq, cremsg := e2termConn1.RecvSubsReq(t)
298 e2termConn1.SendSubsResp(t, crereq, cremsg)
299 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
301 resp, _ := xapp.Subscription.QuerySubscriptions()
302 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
303 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
304 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
306 waiter := rtmgrHttp.AllocNextEvent(false)
307 newSubsId := mainCtrl.get_registry_next_subid(t)
308 xappConn2.SendSubsReq(t, nil, nil)
311 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
312 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
314 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
315 xappConn1.RecvSubsDelResp(t, deltrans)
317 //Wait that subs is cleaned
318 mainCtrl.wait_subs_clean(t, newSubsId, 10)
319 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
321 xappConn1.TestMsgChanEmpty(t)
322 xappConn2.TestMsgChanEmpty(t)
323 e2termConn1.TestMsgChanEmpty(t)
324 mainCtrl.wait_registry_empty(t, 10)
326 mainCtrl.VerifyCounterValues(t)
329 //-----------------------------------------------------------------------------
330 // TestSubDelReqAndRouteDeleteNok
333 // +-------+ +---------+ +---------+ +---------+
334 // | xapp | | submgr | | e2term | | rtmgr |
335 // +-------+ +---------+ +---------+ +---------+
337 // | [SUBS CREATE] | |
342 // |------------->| | |
344 // | |------------->| |
346 // | |<-------------| |
348 // |<-------------| | |
349 // | | RouteDelete | |
350 // | |---------------------------->|
352 // | | RouteDelete | |
353 // | | status:400 | |
354 // | |<----------------------------|
356 func TestSubDelReqAndRouteDeleteNok(t *testing.T) {
357 CaseBegin("TestSubDelReqAndRouteDeleteNok")
359 // Init counter check
360 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
361 Counter{cSubReqFromXapp, 1},
362 Counter{cSubReqToE2, 1},
363 Counter{cSubRespFromE2, 1},
364 Counter{cSubRespToXapp, 1},
365 Counter{cSubDelReqFromXapp, 1},
366 Counter{cRouteDeleteFail, 1},
367 Counter{cSubDelReqToE2, 1},
368 Counter{cSubDelRespFromE2, 1},
369 Counter{cSubDelRespToXapp, 1},
372 cretrans := xappConn1.SendSubsReq(t, nil, nil)
373 crereq, cremsg := e2termConn1.RecvSubsReq(t)
374 e2termConn1.SendSubsResp(t, crereq, cremsg)
375 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
377 resp, _ := xapp.Subscription.QuerySubscriptions()
378 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
379 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
380 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
382 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
383 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
385 waiter := rtmgrHttp.AllocNextEvent(false)
386 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
389 xappConn1.RecvSubsDelResp(t, deltrans)
391 //Wait that subs is cleaned
392 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
394 xappConn1.TestMsgChanEmpty(t)
395 xappConn2.TestMsgChanEmpty(t)
396 e2termConn1.TestMsgChanEmpty(t)
397 mainCtrl.wait_registry_empty(t, 10)
399 mainCtrl.VerifyCounterValues(t)
402 //-----------------------------------------------------------------------------
403 // TestSubMergeDelAndRouteUpdateNok
405 // +-------+ +-------+ +---------+ +---------+
406 // | xapp2 | | xapp1 | | submgr | | e2term |
407 // +-------+ +-------+ +---------+ +---------+
412 // | |------------->| |
415 // | | |------------->|
417 // | | |<-------------|
419 // | |<-------------| |
422 // |--------------------------->| |
425 // |<---------------------------| |
427 // | | SubDelReq 1 | |
428 // | |------------->| |
429 // | | | RouteUpdate |
430 // | | |-----> rtmgr |
432 // | | | RouteUpdate |
433 // | | | status:400 |
434 // | | |<----- rtmgr |
436 // | | SubDelResp 1 | |
437 // | |<-------------| |
440 // |--------------------------->| |
442 // | | | SubDelReq 2 |
443 // | | |------------->|
445 // | | | SubDelReq 2 |
446 // | | |------------->|
448 // | SubDelResp 2 | |
449 // |<---------------------------| |
451 //-----------------------------------------------------------------------------
452 func TestSubMergeDelAndRouteUpdateNok(t *testing.T) {
453 CaseBegin("TestSubMergeDelAndRouteUpdateNok")
455 // Init counter check
456 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
457 Counter{cSubReqFromXapp, 2},
458 Counter{cSubReqToE2, 1},
459 Counter{cSubRespFromE2, 1},
460 Counter{cSubRespToXapp, 2},
461 Counter{cSubDelReqFromXapp, 2},
462 Counter{cRouteDeleteUpdateFail, 1},
463 Counter{cSubDelReqToE2, 1},
464 Counter{cSubDelRespFromE2, 1},
465 Counter{cSubDelRespToXapp, 2},
469 rparams1 := &teststube2ap.E2StubSubsReqParams{}
471 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
472 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
473 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
474 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
477 rparams2 := &teststube2ap.E2StubSubsReqParams{}
479 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
480 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
482 resp, _ := xapp.Subscription.QuerySubscriptions()
483 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
484 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
485 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
488 waiter := rtmgrHttp.AllocNextEvent(false)
489 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
492 xappConn1.RecvSubsDelResp(t, deltrans1)
495 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
496 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
497 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
498 xappConn2.RecvSubsDelResp(t, deltrans2)
499 //Wait that subs is cleaned
500 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
502 xappConn1.TestMsgChanEmpty(t)
503 xappConn2.TestMsgChanEmpty(t)
504 e2termConn1.TestMsgChanEmpty(t)
505 mainCtrl.wait_registry_empty(t, 10)
507 mainCtrl.VerifyCounterValues(t)
510 //-----------------------------------------------------------------------------
512 //-----------------------------------------------------------------------------
513 // TestSubReqAndSubDelOk
516 // +-------+ +---------+ +---------+
517 // | xapp | | submgr | | e2term |
518 // +-------+ +---------+ +---------+
521 // |------------->| |
524 // | |------------->|
527 // | |<-------------|
530 // |<-------------| |
534 // |------------->| |
537 // | |------------->|
540 // | |<-------------|
543 // |<-------------| |
545 //-----------------------------------------------------------------------------
546 func TestSubReqAndSubDelOk(t *testing.T) {
547 CaseBegin("TestSubReqAndSubDelOk")
549 // Init counter check
550 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
551 Counter{cSubReqFromXapp, 1},
552 Counter{cSubReqToE2, 1},
553 Counter{cSubRespFromE2, 1},
554 Counter{cSubRespToXapp, 1},
555 Counter{cSubDelReqFromXapp, 1},
556 Counter{cSubDelReqToE2, 1},
557 Counter{cSubDelRespFromE2, 1},
558 Counter{cSubDelRespToXapp, 1},
561 cretrans := xappConn1.SendSubsReq(t, nil, nil)
562 crereq, cremsg := e2termConn1.RecvSubsReq(t)
563 e2termConn1.SendSubsResp(t, crereq, cremsg)
564 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
566 resp, _ := xapp.Subscription.QuerySubscriptions()
567 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
568 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
569 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
571 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
572 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
574 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
575 xappConn1.RecvSubsDelResp(t, deltrans)
577 //Wait that subs is cleaned
578 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
580 xappConn1.TestMsgChanEmpty(t)
581 xappConn2.TestMsgChanEmpty(t)
582 e2termConn1.TestMsgChanEmpty(t)
583 mainCtrl.wait_registry_empty(t, 10)
585 mainCtrl.VerifyCounterValues(t)
588 //-----------------------------------------------------------------------------
589 // TestSubReqRetransmission
592 // +-------+ +---------+ +---------+
593 // | xapp | | submgr | | e2term |
594 // +-------+ +---------+ +---------+
597 // |------------->| |
600 // | |------------->|
604 // |------------->| |
607 // | |<-------------|
610 // |<-------------| |
615 //-----------------------------------------------------------------------------
616 func TestSubReqRetransmission(t *testing.T) {
617 CaseBegin("TestSubReqRetransmission")
620 cretrans := xappConn1.SendSubsReq(t, nil, nil)
621 crereq, cremsg := e2termConn1.RecvSubsReq(t)
623 seqBef := mainCtrl.get_msgcounter(t)
624 xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq
625 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
627 // hack as there is no real way to see has message be handled.
628 // Previuos counter check just tells that is has been received by submgr
629 // --> artificial delay
630 <-time.After(1 * time.Second)
631 e2termConn1.SendSubsResp(t, crereq, cremsg)
632 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
635 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
636 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
637 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
638 xappConn1.RecvSubsDelResp(t, deltrans)
640 //Wait that subs is cleaned
641 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
643 xappConn1.TestMsgChanEmpty(t)
644 xappConn2.TestMsgChanEmpty(t)
645 e2termConn1.TestMsgChanEmpty(t)
646 mainCtrl.wait_registry_empty(t, 10)
649 //-----------------------------------------------------------------------------
650 // TestSubDelReqRetransmission
653 // +-------+ +---------+ +---------+
654 // | xapp | | submgr | | e2term |
655 // +-------+ +---------+ +---------+
661 // |------------->| |
664 // | |------------->|
669 // |------------->| |
672 // | |<-------------|
675 // |<-------------| |
677 //-----------------------------------------------------------------------------
678 func TestSubDelReqRetransmission(t *testing.T) {
679 CaseBegin("TestSubDelReqRetransmission")
682 cretrans := xappConn1.SendSubsReq(t, nil, nil)
683 crereq, cremsg := e2termConn1.RecvSubsReq(t)
684 e2termConn1.SendSubsResp(t, crereq, cremsg)
685 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
688 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
689 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
691 seqBef := mainCtrl.get_msgcounter(t)
692 xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq
693 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
695 // hack as there is no real way to see has message be handled.
696 // Previuos counter check just tells that is has been received by submgr
697 // --> artificial delay
698 <-time.After(1 * time.Second)
700 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
701 xappConn1.RecvSubsDelResp(t, deltrans)
703 //Wait that subs is cleaned
704 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
706 xappConn1.TestMsgChanEmpty(t)
707 xappConn2.TestMsgChanEmpty(t)
708 e2termConn1.TestMsgChanEmpty(t)
709 mainCtrl.wait_registry_empty(t, 10)
712 //-----------------------------------------------------------------------------
713 // TestSubDelReqCollision
716 // +-------+ +---------+ +---------+
717 // | xapp | | submgr | | e2term |
718 // +-------+ +---------+ +---------+
724 // |------------->| |
727 // | |------------->|
732 // |------------->| |
734 // | | SubDelResp 1 |
735 // | |<-------------|
737 // | SubDelResp 1 | |
738 // |<-------------| |
740 // | SubDelResp 2 | |
741 // |<-------------| |
743 //-----------------------------------------------------------------------------
745 func TestSubDelReqCollision(t *testing.T) {
746 CaseBegin("TestSubDelReqCollision")
749 cretrans := xappConn1.SendSubsReq(t, nil, nil)
750 crereq, cremsg := e2termConn1.RecvSubsReq(t)
751 e2termConn1.SendSubsResp(t, crereq, cremsg)
752 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
755 xappConn1.SendSubsDelReq(t, nil, e2SubsId)
756 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
758 // Subs Delete colliding
759 seqBef := mainCtrl.get_msgcounter(t)
760 deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
761 xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq
762 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
764 // hack as there is no real way to see has message be handled.
765 // Previuos counter check just tells that is has been received by submgr
766 // --> artificial delay
767 <-time.After(1 * time.Second)
769 // Del resp for first and second
770 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
772 // don't care in which order responses are received
773 xappConn1.RecvSubsDelResp(t, nil)
774 xappConn1.RecvSubsDelResp(t, nil)
776 //Wait that subs is cleaned
777 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
779 xappConn1.TestMsgChanEmpty(t)
780 xappConn2.TestMsgChanEmpty(t)
781 e2termConn1.TestMsgChanEmpty(t)
782 mainCtrl.wait_registry_empty(t, 10)
785 //-----------------------------------------------------------------------------
786 // TestSubReqAndSubDelOkTwoParallel
789 // +-------+ +-------+ +---------+ +---------+
790 // | xapp | | xapp | | submgr | | e2term |
791 // +-------+ +-------+ +---------+ +---------+
796 // | |------------->| |
799 // | | |------------->|
802 // |------------------------>| |
805 // | | |------------->|
808 // | | |<-------------|
810 // | |<-------------| |
813 // | | |<-------------|
815 // |<------------------------| |
817 // | | [SUBS 1 DELETE] |
819 // | | [SUBS 2 DELETE] |
822 //-----------------------------------------------------------------------------
824 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
825 CaseBegin("TestSubReqAndSubDelOkTwoParallel")
828 rparams1 := &teststube2ap.E2StubSubsReqParams{}
830 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
831 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
834 rparams2 := &teststube2ap.E2StubSubsReqParams{}
837 rparams2.Req.EventTriggerDefinition.Data.Length = 1
838 rparams2.Req.EventTriggerDefinition.Data.Data = make([]uint8, rparams2.Req.EventTriggerDefinition.Data.Length)
839 rparams2.Req.EventTriggerDefinition.Data.Data[0] = 2
841 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
842 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
845 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
846 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
849 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
850 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
853 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
854 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
855 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
856 xappConn1.RecvSubsDelResp(t, deltrans1)
857 //Wait that subs is cleaned
858 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
861 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
862 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
863 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
864 xappConn2.RecvSubsDelResp(t, deltrans2)
865 //Wait that subs is cleaned
866 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
868 xappConn1.TestMsgChanEmpty(t)
869 xappConn2.TestMsgChanEmpty(t)
870 e2termConn1.TestMsgChanEmpty(t)
871 mainCtrl.wait_registry_empty(t, 10)
874 //-----------------------------------------------------------------------------
875 // TestSameSubsDiffRan
876 // Same subscription to different RANs
879 // +-------+ +---------+ +---------+
880 // | xapp | | submgr | | e2term |
881 // +-------+ +---------+ +---------+
886 // |------------->| |
889 // | |------------->|
892 // | |<-------------|
895 // |<-------------| |
898 // |------------->| |
901 // | |------------->|
904 // | |<-------------|
907 // |<-------------| |
909 // | [SUBS r1 DELETE] |
911 // | [SUBS r2 DELETE] |
914 //-----------------------------------------------------------------------------
915 func TestSameSubsDiffRan(t *testing.T) {
916 CaseBegin("TestSameSubsDiffRan")
919 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
920 xappConn1.SendSubsReq(t, nil, cretrans1)
921 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
922 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
923 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
926 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
927 xappConn1.SendSubsReq(t, nil, cretrans2)
928 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
929 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
930 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
933 deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
934 xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
935 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
936 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
937 xappConn1.RecvSubsDelResp(t, deltrans1)
938 //Wait that subs is cleaned
939 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
942 deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
943 xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
944 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
945 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
946 xappConn1.RecvSubsDelResp(t, deltrans2)
947 //Wait that subs is cleaned
948 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
950 xappConn1.TestMsgChanEmpty(t)
951 xappConn2.TestMsgChanEmpty(t)
952 e2termConn1.TestMsgChanEmpty(t)
953 mainCtrl.wait_registry_empty(t, 10)
956 //-----------------------------------------------------------------------------
957 // TestSubReqRetryInSubmgr
960 // +-------+ +---------+ +---------+
961 // | xapp | | submgr | | e2term |
962 // +-------+ +---------+ +---------+
965 // |------------->| |
968 // | |------------->|
972 // | |------------->|
975 // | |<-------------|
978 // |<-------------| |
983 //-----------------------------------------------------------------------------
985 func TestSubReqRetryInSubmgr(t *testing.T) {
986 CaseBegin("TestSubReqRetryInSubmgr start")
988 // Init counter check
989 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
990 Counter{cSubReqFromXapp, 1},
991 Counter{cSubReqToE2, 1},
992 Counter{cSubReReqToE2, 1},
993 Counter{cSubRespFromE2, 1},
994 Counter{cSubRespToXapp, 1},
995 Counter{cSubDelReqFromXapp, 1},
996 Counter{cSubDelReqToE2, 1},
997 Counter{cSubDelRespFromE2, 1},
998 Counter{cSubDelRespToXapp, 1},
1001 // Xapp: Send SubsReq
1002 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1004 // E2t: Receive 1st SubsReq
1005 e2termConn1.RecvSubsReq(t)
1007 // E2t: Receive 2nd SubsReq and send SubsResp
1008 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1009 e2termConn1.SendSubsResp(t, crereq, cremsg)
1011 // Xapp: Receive SubsResp
1012 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1014 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1015 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1016 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1017 xappConn1.RecvSubsDelResp(t, deltrans)
1019 // Wait that subs is cleaned
1020 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1022 xappConn1.TestMsgChanEmpty(t)
1023 xappConn2.TestMsgChanEmpty(t)
1024 e2termConn1.TestMsgChanEmpty(t)
1025 mainCtrl.wait_registry_empty(t, 10)
1027 mainCtrl.VerifyCounterValues(t)
1030 //-----------------------------------------------------------------------------
1031 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
1034 // +-------+ +---------+ +---------+
1035 // | xapp | | submgr | | e2term |
1036 // +-------+ +---------+ +---------+
1039 // |------------->| |
1042 // | |------------->|
1046 // | |------------->|
1049 // | |------------->|
1052 // | |<-------------|
1055 //-----------------------------------------------------------------------------
1056 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
1057 CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
1059 // Init counter check
1060 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1061 Counter{cSubReqFromXapp, 1},
1062 Counter{cSubReqToE2, 1},
1063 Counter{cSubReReqToE2, 1},
1064 Counter{cSubReqTimerExpiry, 2},
1065 Counter{cSubDelReqToE2, 1},
1066 Counter{cSubDelRespFromE2, 1},
1069 // Xapp: Send SubsReq
1070 xappConn1.SendSubsReq(t, nil, nil)
1072 // E2t: Receive 1st SubsReq
1073 e2termConn1.RecvSubsReq(t)
1075 // E2t: Receive 2nd SubsReq
1076 e2termConn1.RecvSubsReq(t)
1078 // E2t: Send receive SubsDelReq and send SubsResp
1079 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1080 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1082 // Wait that subs is cleaned
1083 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 10)
1085 xappConn1.TestMsgChanEmpty(t)
1086 xappConn2.TestMsgChanEmpty(t)
1087 e2termConn1.TestMsgChanEmpty(t)
1088 mainCtrl.wait_registry_empty(t, 10)
1090 mainCtrl.VerifyCounterValues(t)
1093 //-----------------------------------------------------------------------------
1094 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
1097 // +-------+ +---------+ +---------+
1098 // | xapp | | submgr | | e2term |
1099 // +-------+ +---------+ +---------+
1102 // |------------->| |
1105 // | |------------->|
1109 // | |------------->|
1112 // | |------------->|
1116 // | |------------->|
1120 //-----------------------------------------------------------------------------
1122 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
1123 CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
1125 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1126 Counter{cSubReqFromXapp, 1},
1127 Counter{cSubReqToE2, 1},
1128 Counter{cSubReReqToE2, 1},
1129 Counter{cSubReqTimerExpiry, 2},
1130 Counter{cSubDelReqToE2, 1},
1131 Counter{cSubDelReReqToE2, 1},
1132 Counter{cSubDelReqTimerExpiry, 2},
1135 // Xapp: Send SubsReq
1136 xappConn1.SendSubsReq(t, nil, nil)
1138 // E2t: Receive 1st SubsReq
1139 e2termConn1.RecvSubsReq(t)
1141 // E2t: Receive 2nd SubsReq
1142 e2termConn1.RecvSubsReq(t)
1144 // E2t: Receive 1st SubsDelReq
1145 e2termConn1.RecvSubsDelReq(t)
1147 // E2t: Receive 2nd SubsDelReq
1148 delreq, _ := e2termConn1.RecvSubsDelReq(t)
1150 // Wait that subs is cleaned
1151 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 15)
1153 xappConn1.TestMsgChanEmpty(t)
1154 xappConn2.TestMsgChanEmpty(t)
1155 e2termConn1.TestMsgChanEmpty(t)
1156 mainCtrl.wait_registry_empty(t, 10)
1158 mainCtrl.VerifyCounterValues(t)
1161 //-----------------------------------------------------------------------------
1162 // TestSubReqSubFailRespInSubmgr
1165 // +-------+ +---------+ +---------+
1166 // | xapp | | submgr | | e2term |
1167 // +-------+ +---------+ +---------+
1170 // |------------->| |
1173 // | |------------->|
1176 // | |<-------------|
1179 // | |------------->|
1182 // | |<-------------|
1185 // |<-------------| |
1188 //-----------------------------------------------------------------------------
1190 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1191 CaseBegin("TestSubReqSubFailRespInSubmgr start")
1193 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1194 Counter{cSubReqFromXapp, 1},
1195 Counter{cSubReqToE2, 1},
1196 Counter{cSubFailFromE2, 1},
1197 Counter{cSubFailToXapp, 1},
1200 // Xapp: Send SubsReq
1201 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1203 // E2t: Receive SubsReq and send SubsFail (first)
1204 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1205 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1206 fparams1.Set(crereq1)
1207 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1209 // E2t: Receive SubsDelReq and send SubsDelResp (internal first)
1210 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1211 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1213 // Xapp: Receive SubsFail
1214 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
1216 // Wait that subs is cleaned
1217 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1219 xappConn1.TestMsgChanEmpty(t)
1220 xappConn2.TestMsgChanEmpty(t)
1221 e2termConn1.TestMsgChanEmpty(t)
1222 mainCtrl.wait_registry_empty(t, 10)
1224 mainCtrl.VerifyCounterValues(t)
1227 //-----------------------------------------------------------------------------
1228 // TestSubDelReqRetryInSubmgr
1231 // +-------+ +---------+ +---------+
1232 // | xapp | | submgr | | e2term |
1233 // +-------+ +---------+ +---------+
1235 // | [SUBS CREATE] |
1239 // |------------->| |
1242 // | |------------->|
1245 // | |------------->|
1248 // | |<-------------|
1251 // |<-------------| |
1253 //-----------------------------------------------------------------------------
1255 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1257 CaseBegin("TestSubDelReqRetryInSubmgr start")
1260 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1261 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1262 e2termConn1.SendSubsResp(t, crereq, cremsg)
1263 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1266 // Xapp: Send SubsDelReq
1267 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1269 // E2t: Receive 1st SubsDelReq
1270 e2termConn1.RecvSubsDelReq(t)
1272 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1273 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1274 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1276 // Xapp: Receive SubsDelResp
1277 xappConn1.RecvSubsDelResp(t, deltrans)
1279 // Wait that subs is cleaned
1280 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1282 xappConn1.TestMsgChanEmpty(t)
1283 xappConn2.TestMsgChanEmpty(t)
1284 e2termConn1.TestMsgChanEmpty(t)
1285 mainCtrl.wait_registry_empty(t, 10)
1288 //-----------------------------------------------------------------------------
1289 // TestSubDelReqTwoRetriesNoRespInSubmgr
1292 // +-------+ +---------+ +---------+
1293 // | xapp | | submgr | | e2term |
1294 // +-------+ +---------+ +---------+
1296 // | [SUBS CREATE] |
1300 // |------------->| |
1303 // | |------------->|
1306 // | |------------->|
1310 // |<-------------| |
1312 //-----------------------------------------------------------------------------
1314 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1316 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
1319 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1320 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1321 e2termConn1.SendSubsResp(t, crereq, cremsg)
1322 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1325 // Xapp: Send SubsDelReq
1326 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1328 // E2t: Receive 1st SubsDelReq
1329 e2termConn1.RecvSubsDelReq(t)
1331 // E2t: Receive 2nd SubsDelReq
1332 e2termConn1.RecvSubsDelReq(t)
1334 // Xapp: Receive SubsDelResp
1335 xappConn1.RecvSubsDelResp(t, deltrans)
1337 // Wait that subs is cleaned
1338 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1340 xappConn1.TestMsgChanEmpty(t)
1341 xappConn2.TestMsgChanEmpty(t)
1342 e2termConn1.TestMsgChanEmpty(t)
1343 mainCtrl.wait_registry_empty(t, 10)
1346 //-----------------------------------------------------------------------------
1347 // TestSubDelReqSubDelFailRespInSubmgr
1350 // +-------+ +---------+ +---------+
1351 // | xapp | | submgr | | e2term |
1352 // +-------+ +---------+ +---------+
1354 // | [SUBS CREATE] |
1358 // |------------->| |
1361 // | |------------->|
1364 // | |<-------------|
1367 // |<-------------| |
1370 //-----------------------------------------------------------------------------
1372 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1373 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1375 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1376 Counter{cSubReqFromXapp, 1},
1377 Counter{cSubReqToE2, 1},
1378 Counter{cSubRespFromE2, 1},
1379 Counter{cSubRespToXapp, 1},
1380 Counter{cSubDelReqFromXapp, 1},
1381 Counter{cSubDelReqToE2, 1},
1382 Counter{cSubDelFailFromE2, 1},
1383 Counter{cSubDelRespToXapp, 1},
1387 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1388 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1389 e2termConn1.SendSubsResp(t, crereq, cremsg)
1390 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1392 // Xapp: Send SubsDelReq
1393 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1395 // E2t: Send receive SubsDelReq and send SubsDelFail
1396 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1397 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1399 // Xapp: Receive SubsDelResp
1400 xappConn1.RecvSubsDelResp(t, deltrans)
1402 // Wait that subs is cleaned
1403 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1405 xappConn1.TestMsgChanEmpty(t)
1406 xappConn2.TestMsgChanEmpty(t)
1407 e2termConn1.TestMsgChanEmpty(t)
1408 mainCtrl.wait_registry_empty(t, 10)
1410 mainCtrl.VerifyCounterValues(t)
1413 //-----------------------------------------------------------------------------
1414 // TestSubReqAndSubDelOkSameAction
1417 // +-------+ +-------+ +---------+ +---------+
1418 // | xapp2 | | xapp1 | | submgr | | e2term |
1419 // +-------+ +-------+ +---------+ +---------+
1424 // | |------------->| |
1427 // | | |------------->|
1429 // | | |<-------------|
1431 // | |<-------------| |
1434 // |--------------------------->| |
1437 // |<---------------------------| |
1439 // | | SubDelReq 1 | |
1440 // | |------------->| |
1442 // | | SubDelResp 1 | |
1443 // | |<-------------| |
1445 // | SubDelReq 2 | |
1446 // |--------------------------->| |
1448 // | | | SubDelReq 2 |
1449 // | | |------------->|
1451 // | | | SubDelReq 2 |
1452 // | | |------------->|
1454 // | SubDelResp 2 | |
1455 // |<---------------------------| |
1457 //-----------------------------------------------------------------------------
1458 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
1459 CaseBegin("TestSubReqAndSubDelOkSameAction")
1461 // Init counter check
1462 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1463 Counter{cSubReqFromXapp, 2},
1464 Counter{cSubReqToE2, 1},
1465 Counter{cSubRespFromE2, 1},
1466 Counter{cSubRespToXapp, 2},
1467 Counter{cMergedSubscriptions, 1},
1468 Counter{cUnmergedSubscriptions, 1},
1469 Counter{cSubDelReqFromXapp, 2},
1470 Counter{cSubDelReqToE2, 1},
1471 Counter{cSubDelRespFromE2, 1},
1472 Counter{cSubDelRespToXapp, 2},
1476 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1478 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1479 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1480 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1481 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1484 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1486 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1487 //crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1488 //e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1489 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1491 resp, _ := xapp.Subscription.QuerySubscriptions()
1492 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1493 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1494 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
1497 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1498 //e2termConn1.RecvSubsDelReq(t)
1499 //e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1500 xappConn1.RecvSubsDelResp(t, deltrans1)
1501 //Wait that subs is cleaned
1502 //mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1505 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1506 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1507 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1508 xappConn2.RecvSubsDelResp(t, deltrans2)
1509 //Wait that subs is cleaned
1510 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1512 xappConn1.TestMsgChanEmpty(t)
1513 xappConn2.TestMsgChanEmpty(t)
1514 e2termConn1.TestMsgChanEmpty(t)
1515 mainCtrl.wait_registry_empty(t, 10)
1517 mainCtrl.VerifyCounterValues(t)
1520 //-----------------------------------------------------------------------------
1521 // TestSubReqAndSubDelOkSameActionParallel
1524 // +-------+ +-------+ +---------+ +---------+
1525 // | xapp2 | | xapp1 | | submgr | | e2term |
1526 // +-------+ +-------+ +---------+ +---------+
1531 // | |------------->| |
1534 // | | |------------->|
1536 // |--------------------------->| |
1538 // | | |<-------------|
1540 // | |<-------------| |
1543 // |<---------------------------| |
1545 // | | SubDelReq 1 | |
1546 // | |------------->| |
1548 // | | SubDelResp 1 | |
1549 // | |<-------------| |
1551 // | SubDelReq 2 | |
1552 // |--------------------------->| |
1554 // | | | SubDelReq 2 |
1555 // | | |------------->|
1557 // | | | SubDelReq 2 |
1558 // | | |------------->|
1560 // | SubDelResp 2 | |
1561 // |<---------------------------| |
1563 //-----------------------------------------------------------------------------
1564 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1565 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1568 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1570 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1571 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1574 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1576 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1579 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1580 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1583 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1586 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1587 xappConn1.RecvSubsDelResp(t, deltrans1)
1590 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1591 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1592 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1593 xappConn2.RecvSubsDelResp(t, deltrans2)
1595 //Wait that subs is cleaned
1596 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1598 xappConn1.TestMsgChanEmpty(t)
1599 xappConn2.TestMsgChanEmpty(t)
1600 e2termConn1.TestMsgChanEmpty(t)
1601 mainCtrl.wait_registry_empty(t, 10)
1604 //-----------------------------------------------------------------------------
1605 // TestSubReqAndSubDelNokSameActionParallel
1608 // +-------+ +-------+ +---------+ +---------+
1609 // | xapp2 | | xapp1 | | submgr | | e2term |
1610 // +-------+ +-------+ +---------+ +---------+
1615 // | |------------->| |
1618 // | | |------------->|
1620 // |--------------------------->| |
1622 // | | |<-------------|
1624 // | | | SubDelReq |
1625 // | | |------------->|
1626 // | | | SubDelResp |
1627 // | | |<-------------|
1630 // | |<-------------| |
1633 // |<---------------------------| |
1635 //-----------------------------------------------------------------------------
1636 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1637 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1640 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1642 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1644 // E2t: Receive SubsReq (first)
1645 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1648 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1650 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1651 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1652 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1654 // E2t: send SubsFail (first)
1655 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1656 fparams1.Set(crereq1)
1657 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1659 // E2t: internal delete
1660 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1661 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1664 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1666 xappConn2.RecvSubsFail(t, cretrans2)
1668 //Wait that subs is cleaned
1669 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1671 xappConn1.TestMsgChanEmpty(t)
1672 xappConn2.TestMsgChanEmpty(t)
1673 e2termConn1.TestMsgChanEmpty(t)
1674 mainCtrl.wait_registry_empty(t, 10)
1677 //-----------------------------------------------------------------------------
1678 // TestSubReqAndSubDelNoAnswerSameActionParallel
1681 // +-------+ +-------+ +---------+ +---------+
1682 // | xapp2 | | xapp1 | | submgr | | e2term |
1683 // +-------+ +-------+ +---------+ +---------+
1688 // | |------------->| |
1691 // | | |------------->|
1693 // |--------------------------->| |
1696 // | | |------------->|
1699 // | | | SubDelReq |
1700 // | | |------------->|
1702 // | | | SubDelResp |
1703 // | | |<-------------|
1705 //-----------------------------------------------------------------------------
1706 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1707 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1710 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1712 xappConn1.SendSubsReq(t, rparams1, nil)
1714 crereq1, _ := e2termConn1.RecvSubsReq(t)
1717 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1719 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1720 xappConn2.SendSubsReq(t, rparams2, nil)
1721 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1723 //Req1 (retransmitted)
1724 e2termConn1.RecvSubsReq(t)
1726 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1727 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1729 //Wait that subs is cleaned
1730 mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10)
1732 xappConn1.TestMsgChanEmpty(t)
1733 xappConn2.TestMsgChanEmpty(t)
1734 e2termConn1.TestMsgChanEmpty(t)
1735 mainCtrl.wait_registry_empty(t, 15)
1738 //----------------------------- Policy cases ---------------------------------
1739 //-----------------------------------------------------------------------------
1740 // TestSubReqPolicyAndSubDelOk
1743 // +-------+ +---------+ +---------+
1744 // | xapp | | submgr | | e2term |
1745 // +-------+ +---------+ +---------+
1748 // |------------->| |
1751 // | |------------->|
1754 // | |<-------------|
1757 // |<-------------| |
1761 // |------------->| |
1764 // | |------------->|
1767 // | |<-------------|
1770 // |<-------------| |
1772 //-----------------------------------------------------------------------------
1773 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
1774 CaseBegin("TestSubReqAndSubDelOk")
1776 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1778 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1779 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1781 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1782 e2termConn1.SendSubsResp(t, crereq, cremsg)
1783 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1784 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1785 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1787 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1788 xappConn1.RecvSubsDelResp(t, deltrans)
1790 //Wait that subs is cleaned
1791 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1793 xappConn1.TestMsgChanEmpty(t)
1794 xappConn2.TestMsgChanEmpty(t)
1795 e2termConn1.TestMsgChanEmpty(t)
1796 mainCtrl.wait_registry_empty(t, 10)
1799 //-----------------------------------------------------------------------------
1800 // TestSubReqPolicyChangeAndSubDelOk
1803 // +-------+ +---------+ +---------+
1804 // | xapp | | submgr | | e2term |
1805 // +-------+ +---------+ +---------+
1808 // |------------->| |
1811 // | |------------->|
1814 // | |<-------------|
1817 // |<-------------| |
1820 // |------------->| |
1823 // | |------------->|
1826 // | |<-------------|
1829 // |<-------------| |
1832 // |------------->| |
1835 // | |------------->|
1838 // | |<-------------|
1841 // |<-------------| |
1843 //-----------------------------------------------------------------------------
1845 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
1846 CaseBegin("TestSubReqAndSubDelOk")
1848 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1850 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1851 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1853 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1854 e2termConn1.SendSubsResp(t, crereq, cremsg)
1855 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1858 rparams1.Req.RequestId.InstanceId = e2SubsId
1859 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
1860 xappConn1.SendSubsReq(t, rparams1, cretrans)
1862 crereq, cremsg = e2termConn1.RecvSubsReq(t)
1863 e2termConn1.SendSubsResp(t, crereq, cremsg)
1864 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1865 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1866 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1868 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1869 xappConn1.RecvSubsDelResp(t, deltrans)
1871 //Wait that subs is cleaned
1872 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1874 xappConn1.TestMsgChanEmpty(t)
1875 xappConn2.TestMsgChanEmpty(t)
1876 e2termConn1.TestMsgChanEmpty(t)
1877 mainCtrl.wait_registry_empty(t, 10)
1880 //-----------------------------------------------------------------------------
1881 // TestSubReqAndSubDelOkTwoE2termParallel
1884 // +-------+ +---------+ +---------+ +---------+
1885 // | xapp | | submgr | | e2term1 | | e2term2 |
1886 // +-------+ +---------+ +---------+ +---------+
1891 // |------------->| | |
1894 // | |------------->| |
1897 // |------------->| | |
1900 // | |---------------------------->|
1903 // | |<-------------| |
1905 // |<-------------| | |
1907 // | |<----------------------------|
1909 // |<-------------| | |
1911 // | [SUBS 1 DELETE] | |
1913 // | [SUBS 2 DELETE] | |
1916 //-----------------------------------------------------------------------------
1917 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
1918 CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
1921 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1922 xappConn1.SendSubsReq(t, nil, cretrans1)
1923 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1925 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
1926 xappConn1.SendSubsReq(t, nil, cretrans2)
1927 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
1930 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1931 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1934 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
1935 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1938 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1939 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1940 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1941 xappConn1.RecvSubsDelResp(t, deltrans1)
1942 //Wait that subs is cleaned
1943 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1946 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
1947 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
1948 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
1949 xappConn1.RecvSubsDelResp(t, deltrans2)
1950 //Wait that subs is cleaned
1951 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1953 xappConn1.TestMsgChanEmpty(t)
1954 xappConn2.TestMsgChanEmpty(t)
1955 e2termConn1.TestMsgChanEmpty(t)
1956 e2termConn2.TestMsgChanEmpty(t)
1957 mainCtrl.wait_registry_empty(t, 10)
1960 //-----------------------------------------------------------------------------
1961 // TestSubReqInsertAndSubDelOk
1964 // +-------+ +---------+ +---------+
1965 // | xapp | | submgr | | e2term |
1966 // +-------+ +---------+ +---------+
1969 // |------------->| |
1972 // | |------------->|
1975 // | |<-------------|
1978 // |<-------------| |
1982 // |------------->| |
1985 // | |------------->|
1988 // | |<-------------|
1991 // |<-------------| |
1993 //-----------------------------------------------------------------------------
1994 func TestSubReqInsertAndSubDelOk(t *testing.T) {
1995 CaseBegin("TestInsertSubReqAndSubDelOk")
1997 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1999 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeInsert
2000 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2002 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2003 e2termConn1.SendSubsResp(t, crereq, cremsg)
2004 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2005 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2006 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2008 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2009 xappConn1.RecvSubsDelResp(t, deltrans)
2011 //Wait that subs is cleaned
2012 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2014 xappConn1.TestMsgChanEmpty(t)
2015 xappConn2.TestMsgChanEmpty(t)
2016 e2termConn1.TestMsgChanEmpty(t)
2017 mainCtrl.wait_registry_empty(t, 10)
2020 //-----------------------------------------------------------------------------
2021 // TestSubReqRetransmissionWithSameSubIdDiffXid
2023 // This case simulates case where xApp restarts and starts sending same
2024 // subscription requests which have already subscribed successfully
2027 // +-------+ +---------+ +---------+
2028 // | xapp | | submgr | | e2term |
2029 // +-------+ +---------+ +---------+
2032 // |------------->| |
2035 // | |------------->|
2038 // | |<-------------|
2041 // |<-------------| |
2043 // | xApp restart | |
2046 // | (retrans with same xApp generated subid but diff xid)
2047 // |------------->| |
2050 // |<-------------| |
2052 // | [SUBS DELETE] |
2055 //-----------------------------------------------------------------------------
2056 func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) {
2057 CaseBegin("TestSubReqRetransmissionWithSameSubIdDiffXid")
2060 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2061 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2062 e2termConn1.SendSubsResp(t, crereq, cremsg)
2063 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2065 // xApp restart here
2066 // --> artificial delay
2067 <-time.After(1 * time.Second)
2070 cretrans = xappConn1.SendSubsReq(t, nil, nil) //Retransmitted SubReq
2071 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2074 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2075 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2076 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2077 xappConn1.RecvSubsDelResp(t, deltrans)
2079 //Wait that subs is cleaned
2080 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2082 xappConn1.TestMsgChanEmpty(t)
2083 xappConn2.TestMsgChanEmpty(t)
2084 e2termConn1.TestMsgChanEmpty(t)
2085 mainCtrl.wait_registry_empty(t, 10)
2088 //-----------------------------------------------------------------------------
2089 // TestSubReqNokAndSubDelOkWithRestartInMiddle
2092 // +-------+ +---------+ +---------+
2093 // | xapp | | submgr | | e2term |
2094 // +-------+ +---------+ +---------+
2097 // |------------->| |
2100 // | |------------->|
2105 // | Submgr restart |
2109 // | |------------->|
2112 // | |<-------------|
2115 //-----------------------------------------------------------------------------
2117 func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
2118 CaseBegin("TestSubReqNokAndSubDelOkWithRestartInMiddle")
2120 // Remove possible existing subscrition
2121 mainCtrl.removeExistingSubscriptions(t)
2123 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
2124 xappConn1.SendSubsReq(t, nil, nil)
2125 e2termConn1.RecvSubsReq(t)
2126 mainCtrl.SetResetTestFlag(t, false)
2128 resp, _ := xapp.Subscription.QuerySubscriptions()
2129 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2130 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2131 e2SubsId := uint32(resp[0].SubscriptionID)
2132 t.Logf("e2SubsId = %v", e2SubsId)
2134 mainCtrl.SimulateRestart(t)
2135 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2137 // Submgr send delete for uncompleted subscription
2138 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2139 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2141 // Wait that subs is cleaned
2142 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2144 xappConn1.TestMsgChanEmpty(t)
2145 xappConn2.TestMsgChanEmpty(t)
2146 e2termConn1.TestMsgChanEmpty(t)
2147 mainCtrl.wait_registry_empty(t, 10)
2150 //-----------------------------------------------------------------------------
2151 // TestSubReqAndSubDelOkWithRestartInMiddle
2154 // +-------+ +---------+ +---------+
2155 // | xapp | | submgr | | e2term |
2156 // +-------+ +---------+ +---------+
2159 // |------------->| |
2162 // | |------------->|
2165 // | |<-------------|
2168 // |<-------------| |
2171 // | Submgr restart |
2174 // |------------->| |
2177 // | |------------->|
2180 // | |<-------------|
2183 // |<-------------| |
2185 //-----------------------------------------------------------------------------
2187 func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
2188 CaseBegin("TestSubReqAndSubDelOkWithRestartInMiddle")
2190 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2191 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2192 e2termConn1.SendSubsResp(t, crereq, cremsg)
2193 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2195 // Check subscription
2196 resp, _ := xapp.Subscription.QuerySubscriptions()
2197 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2198 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2199 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2201 mainCtrl.SimulateRestart(t)
2202 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2204 // Check that subscription is restored correctly after restart
2205 resp, _ = xapp.Subscription.QuerySubscriptions()
2206 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2207 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2208 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2210 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2211 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2212 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2213 xappConn1.RecvSubsDelResp(t, deltrans)
2215 //Wait that subs is cleaned
2216 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2218 xappConn1.TestMsgChanEmpty(t)
2219 xappConn2.TestMsgChanEmpty(t)
2220 e2termConn1.TestMsgChanEmpty(t)
2221 mainCtrl.wait_registry_empty(t, 10)
2224 //-----------------------------------------------------------------------------
2225 // TestSubReqAndSubDelOkSameActionWithRestartsInMiddle
2228 // +-------+ +-------+ +---------+ +---------+
2229 // | xapp2 | | xapp1 | | submgr | | e2term |
2230 // +-------+ +-------+ +---------+ +---------+
2235 // | |------------->| |
2238 // | | |------------->|
2240 // | | |<-------------|
2242 // | |<-------------| |
2245 // | submgr restart |
2250 // |--------------------------->| |
2253 // |<---------------------------| |
2255 // | | SubDelReq 1 | |
2256 // | |------------->| |
2258 // | | SubDelResp 1 | |
2259 // | |<-------------| |
2263 // | submgr restart |
2266 // | SubDelReq 2 | |
2267 // |--------------------------->| |
2269 // | | | SubDelReq 2 |
2270 // | | |------------->|
2272 // | | | SubDelReq 2 |
2273 // | | |------------->|
2275 // | SubDelResp 2 | |
2276 // |<---------------------------| |
2278 //-----------------------------------------------------------------------------
2280 func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
2281 CaseBegin("TestSubReqAndSubDelOkSameActionWithRestartsInMiddle")
2284 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2286 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2287 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2288 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2289 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2292 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2294 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2295 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
2297 // Check subscription
2298 resp, _ := xapp.Subscription.QuerySubscriptions() ////////////////////////////////
2299 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2300 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2301 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2303 mainCtrl.SimulateRestart(t)
2304 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2306 // Check that subscription is restored correctly after restart
2307 resp, _ = xapp.Subscription.QuerySubscriptions()
2308 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2309 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2310 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2313 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2314 xapp.Logger.Debug("xappConn1.RecvSubsDelResp")
2315 xappConn1.RecvSubsDelResp(t, deltrans1)
2316 xapp.Logger.Debug("xappConn1.RecvSubsDelResp received")
2318 mainCtrl.SimulateRestart(t)
2319 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2322 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
2323 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2325 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2326 xappConn2.RecvSubsDelResp(t, deltrans2)
2328 //Wait that subs is cleaned
2329 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2331 xappConn1.TestMsgChanEmpty(t)
2332 xappConn2.TestMsgChanEmpty(t)
2333 e2termConn1.TestMsgChanEmpty(t)
2334 mainCtrl.wait_registry_empty(t, 10)
2337 //*****************************************************************************
2338 // REST interface test cases
2339 //*****************************************************************************
2341 //-----------------------------------------------------------------------------
2342 // Test debug GET and POST requests
2345 // +-------+ +---------+
2346 // | user | | submgr |
2347 // +-------+ +---------+
2354 func TestGetSubscriptions(t *testing.T) {
2356 mainCtrl.sendGetRequest(t, "localhost:8088", "/ric/v1/subscriptions")
2359 func TestGetSymptomData(t *testing.T) {
2361 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/symptomdata")
2364 func TestPostdeleteSubId(t *testing.T) {
2366 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/deletesubid=1")
2369 func TestPostEmptyDb(t *testing.T) {
2371 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/emptydb")
2374 func TestGetRestSubscriptions(t *testing.T) {
2376 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/restsubscriptions")
2379 //-----------------------------------------------------------------------------
2380 // TestRESTSubReqAndRouteNok
2383 // +-------+ +---------+ +---------+
2384 // | xapp | | submgr | | rtmgr |
2385 // +-------+ +---------+ +---------+
2388 // |---------------->| |
2390 // | RESTSubResp | |
2391 // |<----------------| |
2392 // | | RouteCreate |
2393 // | |------------->|
2395 // | | RouteCreate |
2397 // | |(Bad request) |
2398 // | |<-------------|
2400 // |<----------------| |
2402 // | [SUBS INT DELETE] |
2404 // | RESTSubDelReq | |
2405 // |---------------->| |
2406 // | RESTSubDelResp | |
2407 // |<----------------| |
2409 //-----------------------------------------------------------------------------
2410 func TestRESTSubReqAndRouteNok(t *testing.T) {
2411 CaseBegin("TestRESTSubReqAndRouteNok")
2413 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2414 Counter{cRestSubReqFromXapp, 1},
2415 Counter{cRestSubRespToXapp, 1},
2416 Counter{cRouteCreateFail, 1},
2417 Counter{cRestSubFailNotifToXapp, 1},
2418 Counter{cRestSubDelReqFromXapp, 1},
2419 Counter{cRestSubDelRespToXapp, 1},
2422 const subReqCount int = 1
2424 // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
2425 waiter := rtmgrHttp.AllocNextSleep(50, false)
2426 newSubsId := mainCtrl.get_registry_next_subid(t)
2429 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2430 restSubId := xappConn1.SendRESTSubsReq(t, params)
2431 xappConn1.ExpectRESTNotificationNok(t, restSubId, "failAll")
2432 waiter.WaitResult(t)
2434 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2435 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
2438 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2440 // Wait that subs is cleaned
2441 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2442 waitSubsCleanup(t, e2SubsId, 10)
2443 mainCtrl.VerifyCounterValues(t)
2446 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
2447 CaseBegin("TestSubReqAndRouteUpdateNok")
2449 //Init counter check
2450 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2451 Counter{cRestSubReqFromXapp, 2},
2452 Counter{cRestSubRespToXapp, 2},
2453 Counter{cSubReqToE2, 1},
2454 Counter{cSubRespFromE2, 1},
2455 Counter{cRestSubNotifToXapp, 1},
2456 Counter{cRestSubFailNotifToXapp, 1},
2457 Counter{cRouteCreateUpdateFail, 1},
2458 Counter{cRestSubDelReqFromXapp, 1},
2459 Counter{cSubDelReqToE2, 1},
2460 Counter{cSubDelRespFromE2, 1},
2461 Counter{cRestSubDelRespToXapp, 1},
2464 var params *teststube2ap.RESTSubsReqParams = nil
2467 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2469 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2471 // xapp2 ROUTE creation shall fail with 400 from rtmgr -> submgr
2472 waiter := rtmgrHttp.AllocNextEvent(false)
2473 newSubsId := mainCtrl.get_registry_next_subid(t)
2474 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
2475 params.SetMeid("RAN_NAME_1")
2476 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2477 xapp.Logger.Debug("Send REST subscriber request for second subscriber : %v", restSubId2)
2478 xappConn2.ExpectRESTNotificationNok(t, restSubId2, "allFail")
2479 waiter.WaitResult(t)
2480 // e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) - TOD: missing delete
2481 xappConn2.WaitRESTNotification(t, restSubId2)
2483 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2485 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2487 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2488 //Wait that subs is cleaned
2489 waitSubsCleanup(t, e2SubsId, 10)
2491 mainCtrl.VerifyCounterValues(t)
2494 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
2495 CaseBegin("TestRESTSubDelReqAndRouteDeleteNok")
2497 // Init counter check
2498 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2499 Counter{cRestSubReqFromXapp, 1},
2500 Counter{cRestSubRespToXapp, 1},
2501 Counter{cSubReqToE2, 1},
2502 Counter{cSubRespFromE2, 1},
2503 Counter{cRestSubNotifToXapp, 1},
2504 Counter{cRestSubDelReqFromXapp, 1},
2505 Counter{cRouteDeleteFail, 1},
2506 Counter{cSubDelReqToE2, 1},
2507 Counter{cSubDelRespFromE2, 1},
2508 Counter{cRestSubDelRespToXapp, 1},
2511 var params *teststube2ap.RESTSubsReqParams = nil
2514 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2516 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2518 waiter := rtmgrHttp.AllocNextEvent(false)
2519 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2520 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2521 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2522 waiter.WaitResult(t)
2524 waitSubsCleanup(t, e2SubsId, 10)
2526 mainCtrl.VerifyCounterValues(t)
2529 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
2530 CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok")
2532 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2533 Counter{cRestSubReqFromXapp, 2},
2534 Counter{cRestSubRespToXapp, 2},
2535 Counter{cSubReqToE2, 1},
2536 Counter{cSubRespFromE2, 1},
2537 Counter{cRestSubNotifToXapp, 2},
2538 Counter{cRestSubDelReqFromXapp, 2},
2539 Counter{cRouteDeleteUpdateFail, 1},
2540 Counter{cSubDelReqToE2, 1},
2541 Counter{cSubDelRespFromE2, 1},
2542 Counter{cRestSubDelRespToXapp, 2},
2545 var params *teststube2ap.RESTSubsReqParams = nil
2548 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2550 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2551 restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1")
2553 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
2555 //Del1, this shall fail on rtmgr side
2556 waiter := rtmgrHttp.AllocNextEvent(false)
2557 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2558 waiter.WaitResult(t)
2560 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"})
2563 deleteXapp2Subscription(t, &restSubId2)
2565 waitSubsCleanup(t, e2SubsId2, 10)
2567 mainCtrl.VerifyCounterValues(t)
2570 //-----------------------------------------------------------------------------
2571 // TestRESTSubReqRetransmission
2574 // +-------+ +---------+ +---------+
2575 // | xapp | | submgr | | e2term |
2576 // +-------+ +---------+ +---------+
2578 // | RESTSubReq1 | |
2579 // |---------------->| |
2581 // | RESTSubResp | |
2582 // |<----------------| |
2584 // | |------------->|
2586 // | RESTSubReq2 | |
2588 // |---------------->| |
2589 // | RESTSubResp(201)| |
2590 // |<----------------| |
2593 // | |<-------------|
2595 // |<----------------| |
2597 // | [SUBS DELETE] |
2600 //-----------------------------------------------------------------------------
2602 func TestRESTSubReqRetransmission(t *testing.T) {
2603 CaseBegin("TestRESTSubReqRetransmission")
2605 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2606 Counter{cRestSubReqFromXapp, 2},
2607 Counter{cRestSubRespToXapp, 2},
2608 Counter{cSubReqToE2, 1},
2609 Counter{cSubRespFromE2, 1},
2610 Counter{cRestSubNotifToXapp, 1},
2611 Counter{cRestSubDelReqFromXapp, 1},
2612 Counter{cSubDelReqToE2, 1},
2613 Counter{cSubDelRespFromE2, 1},
2614 Counter{cRestSubDelRespToXapp, 1},
2616 // Retry/duplicate will get the same way as the first request.
2617 // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
2618 // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
2621 const subReqCount int = 1
2623 // In order to force both XAPP's to create their own subscriptions, force rtmgr to block a while so that 2nd create
2624 // gets into execution before the rtmgrg responds for the first one.
2625 waiter := rtmgrHttp.AllocNextSleep(10, true)
2626 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2627 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
2628 xappConn2.SendRESTSubsReq(t, params)
2630 waiter.WaitResult(t)
2632 xappConn1.WaitListedRestNotifications(t, []string{restSubId1})
2634 // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
2635 // the order is not significant he6re.
2636 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2637 e2termConn1.SendSubsResp(t, crereq, cremsg)
2639 e2SubsIdA := <-xappConn1.ListedRESTNotifications
2640 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
2643 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
2644 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2645 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2647 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId}, 10)
2649 mainCtrl.VerifyCounterValues(t)
2652 //-----------------------------------------------------------------------------
2654 // +-------+ +---------+ +---------+ +---------+
2655 // | xapp | | submgr | | e2term | | rtmgr |
2656 // +-------+ +---------+ +---------+ +---------+
2658 // | RESTSubReq | | |
2659 // |---------------->| | |
2660 // | RESTSubResp | | |
2661 // |<----------------| | |
2662 // | | RouteCreate | |
2663 // | |--------------------------->|
2664 // | | RouteResponse| |
2665 // | |<---------------------------| // The order of these events may vary
2667 // | |------------->| | // The order of these events may vary
2669 // | |<-------------| |
2670 // | RESTNotif1 | | |
2671 // |<----------------| | |
2672 // | RESTSubReq | | |
2673 // | [RETRANS1] | | |
2674 // |---------------->| | |
2675 // | RESTNotif1 | | |
2676 // |<----------------| | |
2677 // | RESTSubReq | | |
2678 // | [RETRANS2] | | |
2679 // |---------------->| | |
2680 // | RESTNotif1 | | |
2681 // |<----------------| | |
2682 // | RESTSubDelReq | | |
2683 // |---------------->| | |
2684 // | | SubDelReq | |
2685 // | |------------->| |
2686 // | RESTSubDelResp| | |
2687 // |<----------------| | |
2688 // | | SubDelResp | |
2689 // | |<-------------| |
2692 //-----------------------------------------------------------------------------
2694 func TestRESTSubReqRetransmissionV2(t *testing.T) {
2695 CaseBegin("TestRESTSubReqRetransmissionV2")
2697 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2698 Counter{cRestSubReqFromXapp, 3},
2699 Counter{cRestSubRespToXapp, 3},
2700 Counter{cSubReqToE2, 1},
2701 Counter{cSubRespFromE2, 1},
2702 Counter{cRestSubNotifToXapp, 3},
2703 Counter{cRestSubDelReqFromXapp, 1},
2704 Counter{cSubDelReqToE2, 1},
2705 Counter{cSubDelRespFromE2, 1},
2706 Counter{cRestSubDelRespToXapp, 1},
2709 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2711 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2713 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2716 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
2718 assert.Equal(t, restSubId_resend, restSubId)
2720 <-time.After(100 * time.Millisecond)
2723 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
2725 assert.Equal(t, restSubId_resend2, restSubId)
2727 <-time.After(100 * time.Millisecond)
2729 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2731 waitSubsCleanup(t, e2SubsId, 10)
2733 //Wait that subs is cleaned
2734 mainCtrl.VerifyCounterValues(t)
2737 //-----------------------------------------------------------------------------
2739 // +-------+ +---------+ +---------+ +---------+
2740 // | xapp | | submgr | | e2term | | rtmgr |
2741 // +-------+ +---------+ +---------+ +---------+
2743 // | RESTSubReq | | |
2744 // |---------------->| | |
2745 // | RESTSubResp | | |
2746 // |<----------------| | |
2747 // | | RouteCreate | |
2748 // | |--------------------------->|
2749 // | | RouteResponse| |
2750 // | |<---------------------------| // The order of these events may vary
2752 // | |------------->| | // The order of these events may vary
2754 // | |<-------------| |
2755 // | RESTNotif1 | | |
2756 // |<----------------| | |
2757 // | RESTSubReq | | |
2758 // | [RETRANS, with RESTsubsId] | |
2759 // |---------------->| | |
2760 // | RESTNotif1 | | |
2761 // |<----------------| | |
2762 // | RESTSubReq | | |
2763 // | [RETRANS, without RESTsubsId] | |
2764 // |---------------->| | |
2765 // | RESTNotif1 | | |
2766 // |<----------------| | |
2767 // | RESTSubDelReq | | |
2768 // |---------------->| | |
2769 // | | SubDelReq | |
2770 // | |------------->| |
2771 // | RESTSubDelResp| | |
2772 // |<----------------| | |
2773 // | | SubDelResp | |
2774 // | |<-------------| |
2777 //-----------------------------------------------------------------------------
2778 func TestRESTSubReqRetransmissionV3(t *testing.T) {
2779 CaseBegin("TestRESTSubReqRetransmissionV3")
2781 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2782 Counter{cRestSubReqFromXapp, 3},
2783 Counter{cRestSubRespToXapp, 3},
2784 Counter{cSubReqToE2, 1},
2785 Counter{cSubRespFromE2, 1},
2786 Counter{cRestSubNotifToXapp, 3},
2787 Counter{cRestSubDelReqFromXapp, 1},
2788 Counter{cSubDelReqToE2, 1},
2789 Counter{cSubDelRespFromE2, 1},
2790 Counter{cRestSubDelRespToXapp, 1},
2793 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2795 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2797 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2799 <-time.After(100 * time.Millisecond)
2801 //1.st resend with subscription ID
2802 params.SetSubscriptionID(&restSubId)
2803 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
2805 assert.Equal(t, restSubId_resend, restSubId)
2807 <-time.After(100 * time.Millisecond)
2809 //2.nd resend without subscription ID (faking app restart)
2810 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
2811 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
2813 assert.Equal(t, restSubId_resend2, restSubId)
2815 <-time.After(100 * time.Millisecond)
2817 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2819 waitSubsCleanup(t, e2SubsId, 10)
2821 //Wait that subs is cleaned
2822 mainCtrl.VerifyCounterValues(t)
2825 //-----------------------------------------------------------------------------
2827 // +-------+ +---------+ +---------+ +---------+
2828 // | xapp | | submgr | | e2term | | rtmgr |
2829 // +-------+ +---------+ +---------+ +---------+
2831 // | RESTSubReq | | |
2832 // |---------------->| | |
2833 // | RESTSubResp | | |
2834 // |<----------------| | |
2835 // | | RouteCreate | |
2836 // | |--------------------------->|
2837 // | | RouteResponse| |
2838 // | |<---------------------------|
2840 // | |------------->| |
2842 // | |<-------------| |
2843 // | RESTNotif1 | | |
2844 // |<----------------| | |
2845 // | RESTSubReq | | |
2846 // | [with RestSUbsId + one additional e2 subDetail]
2847 // |---------------->| | |
2848 // | RESTNotif1 | | |
2849 // | [for initial e2 subDetail] | |
2850 // |<----------------| | |
2851 // | | RouteCreate | |
2852 // | |--------------------------->|
2853 // | | RouteResponse| |
2854 // | |<---------------------------|
2856 // | |------------->| |
2858 // | |<-------------| |
2859 // | RESTNotif1 | | |
2860 // |<----------------| | |
2861 // | RESTSubReq | | |
2862 // | [with RESTsubsId initial request] |
2863 // |---------------->| | |
2864 // | RESTNotif1 | | |
2865 // |<----------------| | |
2866 // | RESTSubDelReq | | |
2867 // |---------------->| | |
2868 // | RESTSubDelResp| | |
2869 // |<----------------| | |
2870 // | | SubDelReq | |
2871 // | |------------->| |
2872 // | | SubDelResp | |
2873 // | |<-------------| |
2874 // | | SubDelReq | |
2875 // | |------------->| |
2876 // | | SubDelResp | |
2877 // | |<-------------| |
2880 //-----------------------------------------------------------------------------
2882 func TestRESTSubReqRetransmissionV4(t *testing.T) {
2883 CaseBegin("TestRESTSubReqRetransmissionV4")
2885 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2886 Counter{cRestSubReqFromXapp, 3},
2887 Counter{cRestSubRespToXapp, 3},
2888 Counter{cSubReqToE2, 2},
2889 Counter{cSubRespFromE2, 2},
2890 Counter{cRestSubNotifToXapp, 4},
2891 Counter{cRestSubDelReqFromXapp, 1},
2892 Counter{cSubDelReqToE2, 2},
2893 Counter{cSubDelRespFromE2, 2},
2894 Counter{cRestSubDelRespToXapp, 1},
2897 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2899 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2901 <-time.After(100 * time.Millisecond)
2903 // Send modified requst, this time with e2 subscriptions.
2904 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
2905 params2.SetSubscriptionID(&restSubId)
2907 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
2908 xappConn1.ExpectAnyNotification(t)
2909 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
2910 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
2911 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
2912 assert.Equal(t, e2SubsId, e2SubsId1)
2914 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
2916 xappConn1.DecrementRequestCount()
2917 xappConn1.ExpectRESTNotification(t, restSubId_resend)
2918 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
2919 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
2920 assert.NotEqual(t, e2SubsId2, 0)
2922 <-time.After(100 * time.Millisecond)
2924 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
2925 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
2926 params.SetSubscriptionID(&restSubId)
2927 xappConn1.ExpectAnyNotification(t)
2928 // Resend the original request again with only one e2 subscription (detail), this time with restsubsid
2929 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
2930 assert.Equal(t, restSubId_resend, restSubId_resend2)
2932 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
2933 assert.Equal(t, e2SubsId, e2SubsId1)
2935 // Delete both e2 subscriptions
2936 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2937 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
2938 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
2940 waitSubsCleanup(t, e2SubsId, 10)
2942 //Wait that subs is cleaned
2943 mainCtrl.VerifyCounterValues(t)
2946 //-----------------------------------------------------------------------------
2948 // +-------+ +---------+ +---------+ +---------+
2949 // | xapp | | submgr | | e2term | | rtmgr |
2950 // +-------+ +---------+ +---------+ +---------+
2952 // | RESTSubReq | | |
2953 // |---------------->| | |
2954 // | RESTSubResp | | |
2955 // |<----------------| | |
2956 // | | RouteCreate | |
2957 // | |--------------------------->|
2958 // | | RouteResponse| |
2959 // | |<---------------------------|
2961 // | |------------->| |
2963 // | |<-------------| |
2964 // | RESTNotif1 | | |
2965 // |<----------------| | |
2966 // | RESTSubReq | | |
2967 // | [with RestSUbsId + one additional e2 subDetail]
2968 // |---------------->| | |
2969 // | RESTNotif1 | | |
2970 // | [for initial e2 subDetail] | |
2971 // |<----------------| | |
2972 // | | RouteCreate | |
2973 // | |--------------------------->|
2974 // | | RouteResponse| |
2975 // | |<---------------------------|
2977 // | |------------->| |
2979 // | |<-------------| |
2980 // | RESTNotif1 | | |
2981 // |<----------------| | |
2982 // | RESTSubReq | | |
2983 // | [without RESTsubsId initial request] |
2984 // |---------------->| | |
2985 // | RESTNotif1 | | |
2986 // |<----------------| | |
2987 // | RESTSubDelReq | | |
2988 // |---------------->| | |
2989 // | RESTSubDelResp| | |
2990 // |<----------------| | |
2991 // | | SubDelReq | |
2992 // | |------------->| |
2993 // | | SubDelResp | |
2994 // | |<-------------| |
2995 // | | SubDelReq | |
2996 // | |------------->| |
2997 // | | SubDelResp | |
2998 // | |<-------------| |
3001 //-----------------------------------------------------------------------------
3003 func TestRESTSubReqRetransmissionV5(t *testing.T) {
3004 CaseBegin("TestRESTSubReqRetransmissionV5")
3006 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3007 Counter{cRestSubReqFromXapp, 3},
3008 Counter{cRestSubRespToXapp, 3},
3009 Counter{cSubReqToE2, 2},
3010 Counter{cSubRespFromE2, 2},
3011 Counter{cRestSubNotifToXapp, 4},
3012 Counter{cRestSubDelReqFromXapp, 1},
3013 Counter{cSubDelReqToE2, 2},
3014 Counter{cSubDelRespFromE2, 2},
3015 Counter{cRestSubDelRespToXapp, 1},
3018 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3020 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3022 <-time.After(100 * time.Millisecond)
3024 // Send modified requst, this time with e2 subscriptions.
3025 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3026 params2.SetSubscriptionID(&restSubId)
3028 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3029 xappConn1.ExpectAnyNotification(t)
3030 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3031 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3033 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3034 assert.Equal(t, e2SubsId, e2SubsId1)
3035 // The first E2 subscription returns immediately, manually decrement expected request count for the remaining request handling
3036 xappConn1.DecrementRequestCount()
3038 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3040 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3041 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3042 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3043 assert.NotEqual(t, e2SubsId2, 0)
3045 <-time.After(100 * time.Millisecond)
3047 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3048 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3049 xappConn1.ExpectAnyNotification(t)
3050 // Resend the original request again with only one e2 subscription (detail), WITHOUT restsubsid
3051 // md5sum shall find the original request
3052 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3053 assert.Equal(t, restSubId_resend, restSubId_resend2)
3055 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3056 assert.Equal(t, e2SubsId, e2SubsId1)
3058 // Delete both e2 subscriptions
3059 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3060 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3061 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3063 waitSubsCleanup(t, e2SubsId, 10)
3065 //Wait that subs is cleaned
3066 mainCtrl.VerifyCounterValues(t)
3069 //-----------------------------------------------------------------------------
3071 // +-------+ +---------+ +---------+ +---------+
3072 // | xapp | | submgr | | e2term | | rtmgr |
3073 // +-------+ +---------+ +---------+ +---------+
3075 // | RESTSubReq | | |
3076 // |---------------->| | |
3077 // | RESTSubResp | | |
3078 // |<----------------| | |
3079 // | | RouteCreate | |
3080 // | |--------------------------->|
3081 // | | RouteResponse| |
3082 // | |<---------------------------|
3084 // | |------------->| |
3086 // | |<-------------| |
3087 // | RESTNotif1 | | |
3088 // |<----------------| | |
3089 // | RESTSubReq | | |
3090 // | [with RestSUbsId + one additional e2 subDetail]
3091 // |---------------->| | |
3092 // | RESTNotif1 | | |
3093 // | [for initial e2 subDetail] | |
3094 // |<----------------| | |
3095 // | | RouteCreate | |
3096 // | |--------------------------->|
3097 // | | RouteResponse| |
3098 // | |<---------------------------|
3100 // | |------------->| |
3102 // | |<-------------| |
3103 // | RESTNotif1 | | |
3104 // |<----------------| | |
3105 // | RESTSubDelReq | | |
3106 // |---------------->| | |
3107 // | RESTSubDelResp| | |
3108 // |<----------------| | |
3109 // | | SubDelReq | |
3110 // | |------------->| |
3111 // | | SubDelResp | |
3112 // | |<-------------| |
3113 // | | SubDelReq | |
3114 // | |------------->| |
3115 // | | SubDelResp | |
3116 // | |<-------------| |
3117 // | RESTSubReq | | |
3118 // | [with RESTsubsId initial request] |
3119 // |---------------->| | |
3120 // | RESTSubResp | | |
3121 // |<----------------| | |
3122 // | | RouteCreate | |
3123 // | |--------------------------->|
3124 // | | RouteResponse| |
3125 // | |<---------------------------|
3127 // | |------------->| |
3129 // | |<-------------| |
3130 // | RESTNotif1 | | |
3131 // |<----------------| | |
3134 //-----------------------------------------------------------------------------
3135 func TestRESTSubReqRetransmissionV6(t *testing.T) {
3136 CaseBegin("TestRESTSubReqRetransmissionV6")
3138 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3139 Counter{cRestSubReqFromXapp, 3},
3140 Counter{cRestSubRespToXapp, 3},
3141 Counter{cSubReqToE2, 3},
3142 Counter{cSubRespFromE2, 3},
3143 Counter{cRestSubNotifToXapp, 4},
3144 Counter{cRestSubDelReqFromXapp, 2},
3145 Counter{cSubDelReqToE2, 3},
3146 Counter{cSubDelRespFromE2, 3},
3147 Counter{cRestSubDelRespToXapp, 2},
3150 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3152 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3154 <-time.After(100 * time.Millisecond)
3156 // Send modified requst, this time with e2 subscriptions.
3157 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3158 params2.SetSubscriptionID(&restSubId)
3160 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3161 xappConn1.ExpectAnyNotification(t)
3162 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3163 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3165 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3166 assert.Equal(t, e2SubsId, e2SubsId1)
3168 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3170 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3171 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3172 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3173 assert.NotEqual(t, e2SubsId2, 0)
3175 <-time.After(100 * time.Millisecond)
3177 // Delete both e2 subscriptions
3178 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3179 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3180 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3182 waitSubsCleanup(t, e2SubsId, 10)
3184 // Resend the original request, we shall find it's previous md5sum/restsubs
3185 // but the restsubscription has been already removed. This shall trigger a
3187 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
3189 <-time.After(100 * time.Millisecond)
3191 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3193 waitSubsCleanup(t, e2SubsId, 10)
3195 //Wait that subs is cleaned
3196 mainCtrl.VerifyCounterValues(t)
3199 func TestRESTSubDelReqRetransmission(t *testing.T) {
3200 CaseBegin("TestRESTSubDelReqRetransmission")
3202 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3203 Counter{cRestSubReqFromXapp, 1},
3204 Counter{cRestSubRespToXapp, 1},
3205 Counter{cSubReqToE2, 1},
3206 Counter{cSubRespFromE2, 1},
3207 Counter{cRestSubNotifToXapp, 1},
3208 Counter{cRestSubDelReqFromXapp, 2},
3209 Counter{cSubDelReqToE2, 1},
3210 Counter{cSubDelRespFromE2, 1},
3211 Counter{cRestSubDelRespToXapp, 1},
3214 var params *teststube2ap.RESTSubsReqParams = nil
3217 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3219 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3222 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3223 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3225 seqBef := mainCtrl.get_msgcounter(t)
3226 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3227 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
3229 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3231 waitSubsCleanup(t, e2SubsId, 10)
3233 mainCtrl.VerifyCounterValues(t)
3236 //-----------------------------------------------------------------------------
3237 // TestRESTSubReqDelReq
3240 // +-------+ +---------+ +---------+
3241 // | xapp | | submgr | | e2term |
3242 // +-------+ +---------+ +---------+
3245 // |---------------->| |
3247 // | RESTSubResp | |
3248 // |<----------------| |
3250 // | |------------->|
3251 // | RESTSubDelReq | |
3252 // |---------------->| |
3253 // | RESTSubDelResp | |
3255 // |<----------------| |
3257 // | |<-------------|
3259 // |<----------------| |
3261 // | [SUBS DELETE] |
3264 //-----------------------------------------------------------------------------
3265 func TestRESTSubReqDelReq(t *testing.T) {
3266 CaseBegin("TestRESTSubReqDelReq")
3268 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3269 Counter{cRestSubReqFromXapp, 1},
3270 Counter{cRestSubRespToXapp, 1},
3271 Counter{cSubReqToE2, 1},
3272 Counter{cSubRespFromE2, 1},
3273 Counter{cRestSubNotifToXapp, 1},
3274 Counter{cRestSubDelReqFromXapp, 2},
3275 Counter{cSubDelReqToE2, 1},
3276 Counter{cSubDelRespFromE2, 1},
3277 Counter{cRestSubDelRespToXapp, 1},
3280 const subReqCount int = 1
3283 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3284 restSubId := xappConn1.SendRESTSubsReq(t, params)
3286 // Del. This will fail as processing of the subscription
3287 // is still ongoing in submgr. Deletion is not allowed before
3288 // subscription creation has been completed.
3289 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3290 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3291 xappConn1.ExpectRESTNotification(t, restSubId)
3292 e2termConn1.SendSubsResp(t, crereq, cremsg)
3293 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3296 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3298 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3299 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3301 // Wait that subs is cleaned
3302 waitSubsCleanup(t, e2SubsId, 10)
3303 mainCtrl.VerifyCounterValues(t)
3307 func TestRESTSubDelReqCollision(t *testing.T) {
3308 CaseBegin("TestRESTSubDelReqCollision - not relevant for REST API")
3311 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
3312 CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel")
3314 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3315 Counter{cRestSubReqFromXapp, 2},
3316 Counter{cRestSubRespToXapp, 2},
3317 Counter{cSubReqToE2, 2},
3318 Counter{cSubRespFromE2, 2},
3319 Counter{cRestSubNotifToXapp, 2},
3320 Counter{cRestSubDelReqFromXapp, 2},
3321 Counter{cSubDelReqToE2, 2},
3322 Counter{cSubDelRespFromE2, 2},
3323 Counter{cRestSubDelRespToXapp, 2},
3327 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3328 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3329 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3332 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3333 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3334 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3336 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3337 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3339 //XappConn1 receives both of the responses
3340 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3343 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3345 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3347 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3348 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3349 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3350 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3353 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3355 deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
3357 //Wait that subs is cleaned
3358 mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
3359 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
3361 mainCtrl.VerifyCounterValues(t)
3365 func TestRESTSameSubsDiffRan(t *testing.T) {
3366 CaseBegin("TestRESTSameSubsDiffRan")
3368 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3369 Counter{cRestSubReqFromXapp, 2},
3370 Counter{cRestSubRespToXapp, 2},
3371 Counter{cSubReqToE2, 2},
3372 Counter{cSubRespFromE2, 2},
3373 Counter{cRestSubNotifToXapp, 2},
3374 Counter{cRestSubDelReqFromXapp, 2},
3375 Counter{cSubDelReqToE2, 2},
3376 Counter{cSubDelRespFromE2, 2},
3377 Counter{cRestSubDelRespToXapp, 2},
3380 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3381 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3382 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3384 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3385 params.SetMeid("RAN_NAME_2")
3386 restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
3387 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3390 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3392 deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
3394 //Wait that subs is cleaned
3395 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3396 waitSubsCleanup(t, e2SubsId2, 10)
3398 mainCtrl.VerifyCounterValues(t)
3402 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
3403 CaseBegin("TestRESTSubReqRetryInSubmgr start")
3405 // Init counter check
3406 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3407 Counter{cRestSubReqFromXapp, 1},
3408 Counter{cRestSubRespToXapp, 1},
3409 Counter{cSubReqToE2, 1},
3410 Counter{cSubReReqToE2, 1},
3411 Counter{cSubRespFromE2, 1},
3412 Counter{cRestSubNotifToXapp, 1},
3413 Counter{cRestSubDelReqFromXapp, 1},
3414 Counter{cSubDelReqToE2, 1},
3415 Counter{cSubDelRespFromE2, 1},
3416 Counter{cRestSubDelRespToXapp, 1},
3419 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3420 restSubId := xappConn1.SendRESTSubsReq(t, params)
3422 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3424 // Catch the first message and ignore it
3425 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3426 xapp.Logger.Debug("Ignore REST subscriber request for subscriber : %v", restSubId)
3428 // The second request is being handled normally
3429 crereq, cremsg = e2termConn1.RecvSubsReq(t)
3430 xappConn1.ExpectRESTNotification(t, restSubId)
3431 e2termConn1.SendSubsResp(t, crereq, cremsg)
3432 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3434 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3436 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3438 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
3439 //Wait that subs is cleaned
3440 waitSubsCleanup(t, e2SubsId, 10)
3442 mainCtrl.VerifyCounterValues(t)
3446 //-----------------------------------------------------------------------------
3447 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3450 // +-------+ +---------+ +---------+
3451 // | xapp | | submgr | | e2term |
3452 // +-------+ +---------+ +---------+
3455 // |---------------->| |
3457 // | RESTSubResp | |
3458 // |<----------------| |
3460 // | |------------->|
3464 // | |------------->|
3467 // | |------------->|
3471 // | |------------->|
3475 // | |<-------------|
3478 // |<----------------| |
3480 // | [SUBS DELETE] |
3483 //-----------------------------------------------------------------------------
3485 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
3486 CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
3488 // Init counter check
3489 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3490 Counter{cRestSubReqFromXapp, 1},
3491 Counter{cRestSubRespToXapp, 1},
3492 Counter{cSubReqToE2, 1},
3493 Counter{cSubReReqToE2, 1},
3494 Counter{cSubReqTimerExpiry, 2},
3495 Counter{cSubDelReqToE2, 1},
3496 Counter{cSubDelRespFromE2, 1},
3499 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3500 restSubId := xappConn1.SendRESTSubsReq(t, params)
3501 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3503 e2termConn1.RecvSubsReq(t)
3504 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3506 e2termConn1.RecvSubsReq(t)
3507 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3509 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3510 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3511 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3512 xappConn1.WaitRESTNotification(t, restSubId)
3514 // Wait that subs is cleaned
3515 waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
3517 mainCtrl.VerifyCounterValues(t)
3520 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
3521 CaseBegin("TestREST2eTermNotRespondingToSubReq start")
3523 // Init counter check
3524 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3525 Counter{cRestSubReqFromXapp, 1},
3526 Counter{cRestSubRespToXapp, 1},
3527 Counter{cSubReqToE2, 1},
3528 Counter{cSubReReqToE2, 1},
3529 Counter{cSubReqTimerExpiry, 2},
3530 Counter{cSubDelReqToE2, 1},
3531 Counter{cSubDelReqTimerExpiry, 2},
3534 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3535 restSubId := xappConn1.SendRESTSubsReq(t, params)
3536 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3538 e2termConn1.RecvSubsReq(t)
3539 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3541 e2termConn1.RecvSubsReq(t)
3542 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3544 e2termConn1.RecvSubsDelReq(t)
3545 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3547 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3548 e2termConn1.RecvSubsDelReq(t)
3549 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3551 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3553 waitSubsCleanup(t, e2SubsId, 10)
3555 mainCtrl.VerifyCounterValues(t)
3559 //-----------------------------------------------------------------------------
3560 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3563 // +-------+ +---------+ +---------+
3564 // | xapp | | submgr | | e2term |
3565 // +-------+ +---------+ +---------+
3568 // |---------------->| |
3570 // | RESTSubResp | |
3571 // |<----------------| |
3573 // | |------------->|
3577 // | |------------->|
3580 // | |------------->|
3584 // | |------------->|
3588 // | |<-------------|
3591 // |<----------------| |
3593 // | [SUBS DELETE] |
3596 //-----------------------------------------------------------------------------
3597 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
3598 CaseBegin("TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr start")
3600 // Init counter check
3601 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3602 Counter{cRestSubReqFromXapp, 1},
3603 Counter{cRestSubRespToXapp, 1},
3604 Counter{cSubReqToE2, 1},
3605 Counter{cSubReReqToE2, 1},
3606 Counter{cSubReqTimerExpiry, 2},
3607 Counter{cSubDelReqToE2, 1},
3608 Counter{cSubDelReReqToE2, 1},
3609 Counter{cSubDelReqTimerExpiry, 2},
3612 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3613 restSubId := xappConn1.SendRESTSubsReq(t, params)
3614 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3616 e2termConn1.RecvSubsReq(t)
3617 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3619 e2termConn1.RecvSubsReq(t)
3620 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3622 e2termConn1.RecvSubsDelReq(t)
3623 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3625 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3626 e2termConn1.RecvSubsDelReq(t)
3627 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3629 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3631 waitSubsCleanup(t, e2SubsId, 10)
3633 mainCtrl.VerifyCounterValues(t)
3636 //-----------------------------------------------------------------------------
3637 // TestRESTSubReqSubFailRespInSubmgr
3640 // +-------+ +---------+ +---------+
3641 // | xapp | | submgr | | e2term |
3642 // +-------+ +---------+ +---------+
3645 // |---------------->| |
3647 // | RESTSubResp | |
3648 // |<----------------| |
3650 // | |------------->|
3653 // | |<-------------|
3656 // | |------------->|
3659 // | |<-------------|
3663 // |<----------------| |
3665 // | [SUBS DELETE] |
3668 //-----------------------------------------------------------------------------
3669 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
3670 CaseBegin("TestRESTSubReqSubFailRespInSubmgr")
3672 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3673 Counter{cRestSubReqFromXapp, 1},
3674 Counter{cRestSubRespToXapp, 1},
3675 Counter{cSubReqToE2, 1},
3676 Counter{cSubFailFromE2, 1},
3677 Counter{cRestSubFailNotifToXapp, 1},
3678 Counter{cRestSubDelReqFromXapp, 1},
3681 const subReqCount int = 1
3682 const e2Timeout int64 = 2
3683 const e2RetryCount int64 = 1
3684 const routingNeeded bool = true
3686 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3687 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
3688 restSubId := xappConn1.SendRESTSubsReq(t, params)
3690 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3691 fparams1 := &teststube2ap.E2StubSubsFailParams{}
3692 fparams1.Set(crereq1)
3693 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3695 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3696 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3697 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3698 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3699 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
3701 // REST subscription sill there to be deleted
3702 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3704 // Wait that subs is cleaned
3705 waitSubsCleanup(t, e2SubsId, 10)
3707 mainCtrl.VerifyCounterValues(t)
3711 //-----------------------------------------------------------------------------
3712 // TestRESTSubDelReqRetryInSubmgr
3715 // +-------+ +---------+ +---------+
3716 // | xapp | | submgr | | e2term |
3717 // +-------+ +---------+ +---------+
3719 // | [SUBS CREATE] |
3722 // | RESTSubDelReq | |
3723 // |---------------->| |
3725 // | RESTSubDelResp | |
3726 // |<----------------| |
3728 // | |------------->|
3731 // | |------------->|
3734 // | |<-------------|
3737 //-----------------------------------------------------------------------------
3738 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
3739 CaseBegin("TestRESTSubDelReqRetryInSubmgr")
3741 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3742 Counter{cRestSubReqFromXapp, 1},
3743 Counter{cRestSubRespToXapp, 1},
3744 Counter{cSubReqToE2, 1},
3745 Counter{cSubRespFromE2, 1},
3746 Counter{cRestSubNotifToXapp, 1},
3747 Counter{cRestSubDelReqFromXapp, 1},
3748 Counter{cSubDelReqToE2, 1},
3749 Counter{cSubDelReReqToE2, 1},
3750 Counter{cSubDelRespFromE2, 1},
3751 Counter{cRestSubDelRespToXapp, 1},
3754 var params *teststube2ap.RESTSubsReqParams = nil
3755 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3758 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3760 // E2t: Receive 1st SubsDelReq
3761 e2termConn1.RecvSubsDelReq(t)
3763 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
3764 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3765 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3767 //Wait that subs is cleaned
3768 waitSubsCleanup(t, e2SubsId, 10)
3770 mainCtrl.VerifyCounterValues(t)
3773 //-----------------------------------------------------------------------------
3774 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
3777 // +-------+ +---------+ +---------+
3778 // | xapp | | submgr | | e2term |
3779 // +-------+ +---------+ +---------+
3781 // | [SUBS CREATE] |
3784 // | RESTSubDelReq | |
3785 // |---------------->| |
3787 // | RESTSubDelResp | |
3788 // |<----------------| |
3790 // | |------------->|
3793 // | |------------->|
3797 //-----------------------------------------------------------------------------
3798 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
3799 CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr")
3801 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3802 Counter{cRestSubReqFromXapp, 1},
3803 Counter{cRestSubRespToXapp, 1},
3804 Counter{cSubReqToE2, 1},
3805 Counter{cSubRespFromE2, 1},
3806 Counter{cRestSubNotifToXapp, 1},
3807 Counter{cRestSubDelReqFromXapp, 1},
3808 Counter{cSubDelReqToE2, 1},
3809 Counter{cSubDelReReqToE2, 1},
3810 Counter{cSubDelRespFromE2, 1},
3811 Counter{cRestSubDelRespToXapp, 1},
3815 var params *teststube2ap.RESTSubsReqParams = nil
3816 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3819 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3821 // E2t: Receive 1st SubsDelReq
3822 e2termConn1.RecvSubsDelReq(t)
3824 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
3825 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3826 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3828 //Wait that subs is cleaned
3829 waitSubsCleanup(t, e2SubsId, 10)
3831 mainCtrl.VerifyCounterValues(t)
3834 //-----------------------------------------------------------------------------
3835 // TestRESTSubDelReqSubDelFailRespInSubmgr
3838 // +-------+ +---------+ +---------+
3839 // | xapp | | submgr | | e2term |
3840 // +-------+ +---------+ +---------+
3842 // | [SUBS CREATE] |
3845 // | RESTSubDelReq | |
3846 // |---------------->| |
3848 // | RESTSubDelResp | |
3849 // |<----------------| |
3851 // | |------------->|
3854 // | |<-------------|
3857 //-----------------------------------------------------------------------------
3858 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
3859 CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr")
3861 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3862 Counter{cRestSubReqFromXapp, 1},
3863 Counter{cRestSubRespToXapp, 1},
3864 Counter{cSubReqToE2, 1},
3865 Counter{cSubRespFromE2, 1},
3866 Counter{cRestSubNotifToXapp, 1},
3867 Counter{cRestSubDelReqFromXapp, 1},
3868 Counter{cSubDelReqToE2, 1},
3869 Counter{cSubDelFailFromE2, 1},
3870 Counter{cRestSubDelRespToXapp, 1},
3874 var params *teststube2ap.RESTSubsReqParams = nil
3875 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3878 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3880 // E2t: Send receive SubsDelReq and send SubsDelFail
3881 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3882 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
3884 //Wait that subs is cleaned
3885 waitSubsCleanup(t, e2SubsId, 10)
3887 mainCtrl.VerifyCounterValues(t)
3890 //-----------------------------------------------------------------------------
3891 // TestRESTSubReqAndSubDelOkSameAction
3894 // +-------+ +-------+ +---------+ +---------+
3895 // | xapp2 | | xapp1 | | submgr | | e2term |
3896 // +-------+ +-------+ +---------+ +---------+
3898 // | | RESTSubReq1 | |
3899 // | |---------------->| |
3901 // | | RESTSubResp1 | |
3902 // | |<----------------| |
3905 // | | |------------->|
3907 // | | |<-------------|
3908 // | | RESTNotif1 | |
3909 // | |<----------------| |
3911 // | RESTSubReq2 | |
3912 // |------------------------------>| |
3914 // | RESTSubResp2 | |
3915 // |<------------------------------| |
3917 // | | RESTNotif2 | |
3918 // |<------------------------------| |
3920 // | | RESTSubDelReq1 | |
3921 // | |---------------->| |
3923 // | | RESTSubDelResp1 | |
3924 // | |<----------------| |
3926 // | RESTSubDelReq2 | |
3927 // |------------------------------>| |
3929 // | RESTSubDelResp2 | |
3930 // |<------------------------------| |
3932 // | | | SubDelReq2 |
3933 // | | |------------->|
3935 // | | | SubDelResp2 |
3936 // | | |<-------------|
3939 //-----------------------------------------------------------------------------
3940 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
3941 CaseBegin("TestRESTSubReqAndSubDelOkSameAction")
3943 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3944 Counter{cRestSubReqFromXapp, 2},
3945 Counter{cRestSubRespToXapp, 2},
3946 Counter{cSubReqToE2, 1},
3947 Counter{cSubRespFromE2, 1},
3948 Counter{cRestSubNotifToXapp, 2},
3949 Counter{cMergedSubscriptions, 1},
3950 Counter{cUnmergedSubscriptions, 1},
3951 Counter{cRestSubDelReqFromXapp, 2},
3952 Counter{cSubDelReqToE2, 1},
3953 Counter{cSubDelRespFromE2, 1},
3954 Counter{cRestSubDelRespToXapp, 2},
3958 var params *teststube2ap.RESTSubsReqParams = nil
3961 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3962 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
3965 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3966 params.SetMeid("RAN_NAME_1")
3968 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
3969 xappConn2.ExpectAnyNotification(t)
3970 waiter := rtmgrHttp.AllocNextSleep(10, true)
3971 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3972 waiter.WaitResult(t)
3973 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
3974 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
3975 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
3977 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
3980 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3983 deleteXapp2Subscription(t, &restSubId2)
3985 //Wait that subs is cleaned
3986 waitSubsCleanup(t, e2SubsId2, 10)
3988 mainCtrl.VerifyCounterValues(t)
3991 //-----------------------------------------------------------------------------
3992 // TestSubReqAndSubDelOkSameActionParallel
3995 // +-------+ +-------+ +---------+ +---------+
3996 // | xapp2 | | xapp1 | | submgr | | e2term |
3997 // +-------+ +-------+ +---------+ +---------+
4002 // | |------------->| |
4005 // | | |------------->|
4007 // |--------------------------->| |
4009 // | | |<-------------|
4011 // | |<-------------| |
4013 // | | |------------->|
4016 // | | |<-------------|
4018 // |<---------------------------| |
4020 // | | SubDelReq 1 | |
4021 // | |------------->| |
4023 // | | SubDelResp 1 | |
4024 // | |<-------------| |
4026 // | SubDelReq 2 | |
4027 // |--------------------------->| |
4029 // | | | SubDelReq 2 |
4030 // | | |------------->|
4032 // | | | SubDelReq 2 |
4033 // | | |------------->|
4035 // | SubDelResp 2 | |
4036 // |<---------------------------| |
4038 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
4039 CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel")
4041 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4042 Counter{cRestSubReqFromXapp, 2},
4043 Counter{cRestSubRespToXapp, 2},
4044 Counter{cSubReqToE2, 2},
4045 Counter{cSubRespFromE2, 2},
4046 Counter{cRestSubNotifToXapp, 2},
4047 Counter{cRestSubDelReqFromXapp, 2},
4048 Counter{cSubDelReqToE2, 2},
4049 Counter{cSubDelRespFromE2, 2},
4050 Counter{cRestSubDelRespToXapp, 2},
4053 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4054 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4055 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4057 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4058 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4060 xappConn1.ExpectRESTNotification(t, restSubId1)
4061 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4062 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4064 xappConn2.ExpectRESTNotification(t, restSubId2)
4065 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
4066 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
4067 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4070 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4071 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4072 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4073 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4076 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4077 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
4078 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
4080 waitSubsCleanup(t, e2SubsId2, 10)
4082 mainCtrl.VerifyCounterValues(t)
4085 //-----------------------------------------------------------------------------
4086 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
4089 // +-------+ +-------+ +---------+ +---------+
4090 // | xapp2 | | xapp1 | | submgr | | e2term |
4091 // +-------+ +-------+ +---------+ +---------+
4095 // | | RESTSubReq1 | |
4096 // | |---------------->| |
4098 // | | RESTSubResp1 | |
4099 // | |<----------------| |
4101 // | | |------------->|
4102 // | RESTSubReq2 | |
4103 // |------------------------------>| |
4105 // | RESTSubDelResp2 | |
4106 // |<------------------------------| |
4108 // | | |------------->|
4111 // | | | SubDelReq |
4112 // | | |------------->|
4114 // | | | SubDelResp |
4115 // | | |<-------------|
4116 // | | RESTNotif1 | |
4117 // | | unsuccess | |
4118 // | |<----------------| |
4120 // | | unsuccess | |
4121 // |<------------------------------| |
4123 // | | RESTSubDelReq1 | |
4124 // | |---------------->| |
4126 // | | RESTSubDelResp1 | |
4127 // | |<----------------| |
4129 // | RESTSubDelReq2 | |
4130 // |------------------------------>| |
4132 // | RESTSubDelResp2 | |
4133 // |<------------------------------| |
4135 //-----------------------------------------------------------------------------
4136 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
4137 CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
4139 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4140 Counter{cRestSubReqFromXapp, 2},
4141 Counter{cRestSubRespToXapp, 2},
4142 Counter{cSubReqToE2, 1},
4143 Counter{cRestSubFailNotifToXapp, 2},
4144 Counter{cRestSubDelReqFromXapp, 2},
4145 Counter{cSubDelReqToE2, 1},
4146 Counter{cSubDelRespFromE2, 1},
4147 Counter{cRestSubDelRespToXapp, 2},
4150 const subReqCount int = 1
4153 params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4154 restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
4155 crereq1, _ := e2termConn1.RecvSubsReq(t)
4158 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4159 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4160 params2.SetMeid("RAN_NAME_1")
4161 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4162 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4164 //Req1 (retransmitted)
4165 e2termConn1.RecvSubsReq(t)
4167 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4169 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4170 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4172 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4173 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4174 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4175 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4178 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4181 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4183 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
4185 //Wait that subs is cleaned
4186 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4188 mainCtrl.VerifyCounterValues(t)
4191 //-----------------------------------------------------------------------------
4192 // TestRESTSubReqAndSubDelNokSameActionParallel
4195 // +-------+ +-------+ +---------+ +---------+
4196 // | xapp2 | | xapp1 | | submgr | | e2term |
4197 // +-------+ +-------+ +---------+ +---------+
4201 // | | RESTSubReq1 | |
4202 // | |---------------->| |
4204 // | | RESTSubResp1 | |
4205 // | |<----------------| |
4207 // | | |------------->|
4208 // | RESTSubReq2 | |
4209 // |------------------------------>| |
4211 // | RESTSubDelResp2 | |
4212 // |<------------------------------| |
4214 // | | |<-------------|
4216 // | | RESTNotif1 | |
4217 // | | unsuccess | |
4218 // | |<----------------| |
4220 // | | unsuccess | |
4221 // |<------------------------------| |
4222 // | | | SubDelReq |
4223 // | | |------------->|
4224 // | | | SubDelResp |
4225 // | | |<-------------|
4227 // | | RESTSubDelReq1 | |
4228 // | |---------------->| |
4230 // | | RESTSubDelResp1 | |
4231 // | |<----------------| |
4233 // | RESTSubDelReq2 | |
4234 // |------------------------------>| |
4236 // | RESTSubDelResp2 | |
4237 // |<------------------------------| |
4239 //-----------------------------------------------------------------------------
4240 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
4241 CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
4243 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4244 Counter{cRestSubReqFromXapp, 2},
4245 Counter{cRestSubRespToXapp, 2},
4246 Counter{cSubReqToE2, 1},
4247 Counter{cSubFailFromE2, 1},
4248 Counter{cRestSubFailNotifToXapp, 2},
4249 Counter{cRestSubDelReqFromXapp, 2},
4250 Counter{cSubDelReqToE2, 1},
4251 Counter{cSubDelRespFromE2, 1},
4252 Counter{cRestSubDelRespToXapp, 2},
4255 const subReqCount int = 1
4258 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4259 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4260 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4263 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4264 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4265 params2.SetMeid("RAN_NAME_1")
4266 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4267 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4269 // E2t: send SubsFail (first)
4270 fparams1 := &teststube2ap.E2StubSubsFailParams{}
4271 fparams1.Set(crereq1)
4272 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
4274 // E2t: internal delete
4275 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4276 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4277 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4279 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4280 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4281 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4282 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4285 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4288 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4290 //Wait that subs is cleaned
4291 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4292 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
4294 mainCtrl.VerifyCounterValues(t)
4297 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
4298 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4300 // Init counter check
4301 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4302 Counter{cRestSubReqFromXapp, 1},
4303 Counter{cRestSubRespToXapp, 1},
4304 Counter{cSubReqToE2, 1},
4305 Counter{cSubRespFromE2, 1},
4306 Counter{cRestSubNotifToXapp, 1},
4307 Counter{cRestSubDelReqFromXapp, 1},
4308 Counter{cSubDelReqToE2, 1},
4309 Counter{cSubDelRespFromE2, 1},
4310 Counter{cRestSubDelRespToXapp, 1},
4313 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4314 restSubId := xappConn1.SendRESTSubsReq(t, params)
4315 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
4317 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4318 xappConn1.ExpectRESTNotification(t, restSubId)
4319 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4320 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4321 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
4323 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4324 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4325 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4327 // Wait that subs is cleaned
4328 waitSubsCleanup(t, e2SubsId, 10)
4329 mainCtrl.VerifyCounterValues(t)
4332 //-----------------------------------------------------------------------------
4333 // TestRESTSubReqPolicyChangeAndSubDelOk
4336 // +-------+ +---------+ +---------+
4337 // | xapp | | submgr | | e2term |
4338 // +-------+ +---------+ +---------+
4341 // |---------------->| |
4343 // | RESTSubResp | |
4344 // |<----------------| |
4346 // | |------------->|
4349 // | |<-------------|
4352 // |<----------------| |
4355 // |---------------->| |
4357 // | RESTSubResp | |
4358 // |<----------------| |
4360 // | |------------->|
4363 // | |<-------------|
4366 // |<----------------| |
4368 // | RESTSubDelReq | |
4369 // |---------------->| |
4372 // | |------------->|
4375 // | |<-------------|
4377 // | RESTSubDelResp | |
4378 // |<----------------| |
4380 //-----------------------------------------------------------------------------
4381 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
4382 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4384 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4385 Counter{cRestSubReqFromXapp, 2},
4386 Counter{cRestSubRespToXapp, 2},
4387 Counter{cSubReqToE2, 2},
4388 Counter{cSubRespFromE2, 2},
4389 Counter{cRestSubNotifToXapp, 2},
4390 Counter{cRestSubDelReqFromXapp, 1},
4391 Counter{cSubDelReqToE2, 1},
4392 Counter{cSubDelRespFromE2, 1},
4393 Counter{cRestSubDelRespToXapp, 1},
4396 const subReqCount int = 1
4397 const e2Timeout int64 = 1
4398 const e2RetryCount int64 = 0
4399 const routingNeeded bool = true
4402 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4403 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4404 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4407 // GetRESTSubsReqPolicyParams sets some counters on tc side.
4409 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4410 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4411 params.SetSubscriptionID(&restSubId)
4412 params.SetTimeToWait("w200ms")
4413 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
4416 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4418 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4419 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4421 // Wait that subs is cleaned
4422 waitSubsCleanup(t, e2SubsId, 10)
4423 mainCtrl.VerifyCounterValues(t)
4426 //-----------------------------------------------------------------------------
4427 // TestRESTSubReqPolicyChangeNOk
4430 // +-------+ +---------+ +---------+
4431 // | xapp | | submgr | | e2term |
4432 // +-------+ +---------+ +---------+
4435 // |---------------->| |
4437 // | RESTSubResp | |
4438 // |<----------------| |
4440 // | |------------->|
4443 // | |<-------------|
4446 // |<----------------| |
4449 // |---------------->| |
4451 // | RESTSubUpdateFail(400 Bad request)
4453 // | RESTSubDelReq | |
4454 // |---------------->| |
4457 // | |------------->|
4460 // | |<-------------|
4462 // | RESTSubDelResp | |
4463 // |<----------------| |
4465 //-----------------------------------------------------------------------------
4466 func TestRESTSubReqPolicyChangeNOk(t *testing.T) {
4467 CaseBegin("TestRESTSubReqPolicyChangeNOk")
4469 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4470 Counter{cRestSubReqFromXapp, 2},
4471 Counter{cRestSubRespToXapp, 1},
4472 Counter{cSubReqToE2, 1},
4473 Counter{cSubRespFromE2, 1},
4474 Counter{cRestSubNotifToXapp, 1},
4475 Counter{cRestSubFailToXapp, 1},
4476 Counter{cRestSubDelReqFromXapp, 1},
4477 Counter{cSubDelReqToE2, 1},
4478 Counter{cSubDelRespFromE2, 1},
4479 Counter{cRestSubDelRespToXapp, 1},
4483 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4484 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4487 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4489 restSubIdUpd := strings.ToUpper(restSubId) // This makes RESTSubReq to fail
4490 params.SetSubscriptionID(&restSubIdUpd)
4491 params.SetTimeToWait("w200ms")
4493 restSubId2 := xappConn1.SendRESTSubsReq(t, params)
4494 assert.Equal(t, restSubId2, "")
4497 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4499 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4500 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4502 // Wait that subs is cleaned
4503 waitSubsCleanup(t, e2SubsId, 10)
4504 mainCtrl.VerifyCounterValues(t)
4507 //-----------------------------------------------------------------------------
4508 // TestRESTSubReqAndSubDelOkTwoE2termParallel
4511 // +-------+ +---------+ +---------+ +---------+
4512 // | xapp | | submgr | | e2term1 | | e2term2 |
4513 // +-------+ +---------+ +---------+ +---------+
4517 // | RESTSubReq1 | | |
4518 // |---------------->| | |
4520 // | RESTSubResp1 | | |
4521 // |<----------------| | |
4523 // | |------------->| |
4525 // | RESTSubReq2 | | |
4526 // |---------------->| | |
4528 // | RESTSubResp2 | | |
4529 // |<----------------| | |
4531 // | |---------------------------->|
4534 // | |<-------------| |
4535 // | RESTNotif1 | | |
4536 // |<----------------| | |
4538 // | |<----------------------------|
4539 // | RESTNotif2 | | |
4540 // |<----------------| | |
4542 // | [SUBS 1 DELETE] | |
4544 // | [SUBS 2 DELETE] | |
4547 //-----------------------------------------------------------------------------
4548 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
4549 CaseBegin("TestRESTSubReqAndSubDelOkTwoE2termParallel")
4551 // Init counter check
4552 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4553 Counter{cRestSubReqFromXapp, 2},
4554 Counter{cRestSubRespToXapp, 2},
4555 Counter{cSubReqToE2, 2},
4556 Counter{cSubRespFromE2, 2},
4557 Counter{cRestSubNotifToXapp, 2},
4558 Counter{cRestSubDelReqFromXapp, 2},
4559 Counter{cSubDelReqToE2, 2},
4560 Counter{cSubDelRespFromE2, 2},
4561 Counter{cRestSubDelRespToXapp, 2},
4564 const subReqCount int = 1
4567 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4568 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4569 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4572 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4573 params.SetMeid("RAN_NAME_11")
4574 // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
4575 // would not work as notification would not be received
4576 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4577 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
4580 xappConn1.ExpectRESTNotification(t, restSubId1)
4581 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4582 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4583 xapp.Logger.Debug("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
4586 xappConn2.ExpectRESTNotification(t, restSubId2)
4587 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
4588 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4589 xapp.Logger.Debug("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
4592 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4593 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4594 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4596 // Wait that subs is cleaned
4597 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4600 xappConn1.SendRESTSubsDelReq(t, &restSubId2)
4601 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
4602 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
4604 // Wait that subs is cleaned
4605 waitSubsCleanup(t, e2SubsId2, 10)
4607 mainCtrl.VerifyCounterValues(t)
4610 //-----------------------------------------------------------------------------
4611 // TestRESTSubReqAsn1EncodeFail
4613 // In this case submgr send RICSubscriptionDeleteRequest after encode failure which should not happen!
4615 // +-------+ +---------+ +---------+
4616 // | xapp | | submgr | | e2term |
4617 // +-------+ +---------+ +---------+
4620 // |---------------->| |
4622 // | RESTSubResp | |
4623 // |<----------------| |
4624 // | RESTSubDelReq | |
4625 // |---------------->| |
4626 // | RESTSubDelResp | |
4628 // |<----------------| |
4631 //-----------------------------------------------------------------------------
4632 func TestRESTSubReqAsn1EncodeFail(t *testing.T) {
4633 CaseBegin("TestRESTSubReqAsn1EncodeFail")
4635 xapp.Logger.Debug("Xapp-frame, v0.8.1 sufficient REST API validation")
4639 //-----------------------------------------------------------------------------
4640 // TestRESTSubReqInsertAndSubDelOk
4643 // +-------+ +---------+ +---------+
4644 // | xapp | | submgr | | e2term |
4645 // +-------+ +---------+ +---------+
4648 // |---------------->| |
4650 // | RESTSubResp | |
4651 // |<----------------| |
4654 // | |------------->|
4657 // | |<-------------|
4659 // |<----------------| |
4662 // | RESTSubDelReq | |
4663 // |---------------->| |
4666 // | |------------->|
4669 // | |<-------------|
4671 // | RESTSubDelResp| |
4672 // |<----------------| |
4674 //-----------------------------------------------------------------------------
4675 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
4676 CaseBegin("TestRESTInsertSubReqAndSubDelOk")
4678 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4679 Counter{cRestSubReqFromXapp, 1},
4680 Counter{cRestSubRespToXapp, 1},
4681 Counter{cSubReqToE2, 1},
4682 Counter{cSubRespFromE2, 1},
4683 Counter{cRestSubNotifToXapp, 1},
4684 Counter{cRestSubDelReqFromXapp, 1},
4685 Counter{cSubDelReqToE2, 1},
4686 Counter{cSubDelRespFromE2, 1},
4687 Counter{cRestSubDelRespToXapp, 1},
4690 const subReqCount int = 1
4692 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4693 params.SetSubActionTypes("insert")
4696 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4699 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4701 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4702 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4704 // Wait that subs is cleaned
4705 waitSubsCleanup(t, e2SubsId, 10)
4706 mainCtrl.VerifyCounterValues(t)
4709 //-----------------------------------------------------------------------------
4710 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
4713 // +-------+ +---------+ +---------+
4714 // | xapp | | submgr | | e2term |
4715 // +-------+ +---------+ +---------+
4718 // |------------->| |
4721 // | |------------->|
4726 // | Submgr restart |
4730 // | |------------->|
4733 // | |<-------------|
4736 //-----------------------------------------------------------------------------
4737 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
4738 CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle")
4740 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4741 Counter{cRestSubReqFromXapp, 1},
4742 Counter{cRestSubRespToXapp, 1},
4743 Counter{cSubReqToE2, 1},
4744 Counter{cSubDelReqFromXapp, 1},
4745 Counter{cSubDelReqToE2, 1},
4746 Counter{cSubDelRespFromE2, 1},
4749 const subReqCount int = 1
4751 // Remove possible existing subscription
4752 mainCtrl.removeExistingSubscriptions(t)
4754 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4757 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
4758 restSubId := xappConn1.SendRESTSubsReq(t, params)
4759 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
4761 e2termConn1.RecvSubsReq(t)
4763 mainCtrl.SetResetTestFlag(t, false)
4765 mainCtrl.SimulateRestart(t)
4766 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4769 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4770 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4772 xappConn1.TestMsgChanEmpty(t)
4773 xappConn2.TestMsgChanEmpty(t)
4774 e2termConn1.TestMsgChanEmpty(t)
4775 mainCtrl.wait_registry_empty(t, 10)
4777 mainCtrl.VerifyCounterValues(t)
4780 //-----------------------------------------------------------------------------
4781 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
4784 // +-------+ +---------+ +---------+
4785 // | xapp | | submgr | | e2term |
4786 // +-------+ +---------+ +---------+
4789 // |---------------->| |
4791 // | RESTSubResp | |
4792 // |<----------------| |
4794 // | |------------->|
4797 // | |<-------------|
4800 // |<----------------| |
4803 // | Submgr restart |
4805 // | RESTSubDelReq | |
4806 // |---------------->| |
4809 // | |------------->|
4812 // | |<-------------|
4814 // | RESTSubDelResp | |
4815 // |<----------------| |
4817 //-----------------------------------------------------------------------------
4819 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
4820 CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle")
4822 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4823 Counter{cRestSubReqFromXapp, 1},
4824 Counter{cRestSubRespToXapp, 1},
4825 Counter{cSubReqToE2, 1},
4826 Counter{cSubRespFromE2, 1},
4827 Counter{cRestSubNotifToXapp, 1},
4828 Counter{cRestSubDelReqFromXapp, 1},
4829 Counter{cSubDelReqToE2, 1},
4830 Counter{cRestSubDelRespToXapp, 1},
4833 // Remove possible existing subscription
4834 mainCtrl.removeExistingSubscriptions(t)
4836 var params *teststube2ap.RESTSubsReqParams = nil
4838 // Create subscription
4839 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4840 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
4842 // Check subscription
4843 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4845 mainCtrl.SimulateRestart(t)
4846 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4848 // Check subscription
4849 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4851 // Delete subscription
4852 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
4854 //Wait that subs is cleaned
4855 waitSubsCleanup(t, e2SubsId, 10)
4857 mainCtrl.VerifyCounterValues(t)
4860 //-----------------------------------------------------------------------------
4861 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
4864 // +-------+ +-------+ +---------+ +---------+
4865 // | xapp2 | | xapp1 | | submgr | | e2term |
4866 // +-------+ +-------+ +---------+ +---------+
4868 // | | RESTSubReq1 | |
4869 // | |---------------->| |
4871 // | | RESTSubResp1 | |
4872 // | |<----------------| |
4875 // | | |------------->|
4877 // | | |<-------------|
4878 // | | RESTNotif1 | |
4879 // | |<----------------| |
4881 // | RESTSubReq2 | |
4882 // |------------------------------>| |
4884 // | RESTSubResp2 | |
4885 // |<------------------------------| |
4887 // | | RESTNotif2 | |
4888 // |<------------------------------| |
4890 // | | Submgr restart |
4892 // | | RESTSubDelReq1 | |
4893 // | |---------------->| |
4895 // | | RESTSubDelResp1 | |
4896 // | |<----------------| |
4898 // | | Submgr restart |
4900 // | RESTSubDelReq2 | |
4901 // |------------------------------>| |
4903 // | RESTSubDelResp2 | |
4904 // |<------------------------------| |
4906 // | | | SubDelReq2 |
4907 // | | |------------->|
4909 // | | | SubDelResp2 |
4910 // | | |<-------------|
4913 //-----------------------------------------------------------------------------
4915 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
4916 CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
4918 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4919 Counter{cRestSubReqFromXapp, 2},
4920 Counter{cRestSubRespToXapp, 2},
4921 Counter{cSubReqToE2, 1},
4922 Counter{cSubRespFromE2, 1},
4923 Counter{cRestSubNotifToXapp, 2},
4924 Counter{cMergedSubscriptions, 1},
4925 Counter{cUnmergedSubscriptions, 1},
4926 Counter{cRestSubDelReqFromXapp, 2},
4927 Counter{cSubDelReqToE2, 1},
4928 Counter{cSubDelRespFromE2, 1},
4929 Counter{cRestSubDelRespToXapp, 2},
4932 // Remove possible existing subscription
4933 mainCtrl.removeExistingSubscriptions(t)
4935 var params *teststube2ap.RESTSubsReqParams = nil
4937 // Create subscription 1
4938 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4939 xapp.Logger.Debug("Send REST subscriber request for subscriber 1 : %v", restSubId1)
4941 // Create subscription 2 with same action
4942 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4943 params.SetMeid("RAN_NAME_1")
4944 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4945 xappConn2.ExpectAnyNotification(t)
4946 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4947 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
4948 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
4949 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
4951 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
4953 mainCtrl.SimulateRestart(t)
4954 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4956 // Delete subscription 1, and wait until it has removed the first endpoint
4957 subepcnt := mainCtrl.get_subs_entrypoint_cnt(t, e2SubsId1)
4958 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4959 mainCtrl.wait_subs_entrypoint_cnt_change(t, e2SubsId1, subepcnt, 10)
4961 mainCtrl.SimulateRestart(t)
4962 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4963 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
4965 // Delete subscription 2
4966 deleteXapp2Subscription(t, &restSubId2)
4968 //Wait that subs is cleaned
4969 waitSubsCleanup(t, e2SubsId2, 10)
4971 mainCtrl.VerifyCounterValues(t)
4974 //-----------------------------------------------------------------------------
4975 // TestRESTReportSubReqAndSubDelOk
4978 // +-------+ +---------+ +---------+
4979 // | xapp | | submgr | | e2term |
4980 // +-------+ +---------+ +---------+
4983 // |---------------->| |
4985 // | RESTSubResp | |
4986 // |<----------------| |
4989 // | |------------->|
4992 // | |<-------------|
4994 // |<----------------| |
4996 // | |------------->|
4999 // | |<-------------|
5001 // |<----------------| |
5005 // | RESTSubDelReq | |
5006 // |---------------->| |
5009 // | |------------->|
5012 // | |<-------------|
5014 // | RESTSubDelResp| |
5015 // |<----------------| |
5017 //-----------------------------------------------------------------------------
5019 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
5020 CaseBegin("TestRESTReportSubReqAndSubDelOk")
5021 const subReqCount int = 1
5023 RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
5026 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5027 xapp.Logger.Debug("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
5030 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5031 restSubId := xappConn1.SendRESTSubsReq(t, params)
5033 var e2SubsId []uint32
5034 for i := 0; i < subReqCount; i++ {
5035 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5036 xappConn1.ExpectRESTNotification(t, restSubId)
5038 e2termConn1.SendSubsResp(t, crereq, cremsg)
5039 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5040 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5041 e2SubsId = append(e2SubsId, instanceId)
5042 resp, _ := xapp.Subscription.QuerySubscriptions()
5043 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
5044 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
5045 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
5050 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5052 for i := 0; i < subReqCount; i++ {
5053 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5054 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5057 // Wait that subs is cleaned
5058 for i := 0; i < subReqCount; i++ {
5059 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5062 xappConn1.TestMsgChanEmpty(t)
5063 e2termConn1.TestMsgChanEmpty(t)
5064 mainCtrl.wait_registry_empty(t, 10)
5068 func TestRESTPolicySubReqAndSubDelOk(t *testing.T) {
5069 CaseBegin("TestRESTPolicySubReqAndSubDelOk")
5073 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5077 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5080 func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5081 xapp.Logger.Debug("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
5084 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5085 restSubId := xappConn1.SendRESTSubsReq(t, params)
5087 var e2SubsId []uint32
5088 for i := 0; i < subReqCount; i++ {
5089 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5090 xappConn1.ExpectRESTNotification(t, restSubId)
5091 e2termConn1.SendSubsResp(t, crereq, cremsg)
5092 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5093 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5094 e2SubsId = append(e2SubsId, instanceId)
5098 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5100 for i := 0; i < subReqCount; i++ {
5101 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5102 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5105 // Wait that subs is cleaned
5106 for i := 0; i < subReqCount; i++ {
5107 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5109 xappConn1.TestMsgChanEmpty(t)
5110 e2termConn1.TestMsgChanEmpty(t)
5111 mainCtrl.wait_registry_empty(t, 10)
5114 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
5116 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5117 Counter{cRestSubReqFromXapp, 1},
5118 Counter{cRestSubRespToXapp, 1},
5119 Counter{cSubReqToE2, 2},
5120 Counter{cSubRespFromE2, 2},
5121 Counter{cRestSubNotifToXapp, 2},
5122 Counter{cRestSubDelReqFromXapp, 1},
5123 Counter{cSubDelReqToE2, 2},
5124 Counter{cSubDelRespFromE2, 2},
5125 Counter{cRestSubDelRespToXapp, 1},
5128 const subReqCount int = 2
5131 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5132 restSubId := xappConn1.SendRESTSubsReq(t, params)
5133 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5135 assert.Equal(t, len(e2SubsIds), 2)
5138 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5139 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5141 xappConn1.TestMsgChanEmpty(t)
5142 e2termConn1.TestMsgChanEmpty(t)
5143 mainCtrl.wait_registry_empty(t, 10)
5145 mainCtrl.VerifyCounterValues(t)
5147 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
5149 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5150 Counter{cRestSubReqFromXapp, 1},
5151 Counter{cRestSubRespToXapp, 1},
5152 Counter{cSubReqToE2, 19},
5153 Counter{cSubRespFromE2, 19},
5154 Counter{cRestSubNotifToXapp, 19},
5155 Counter{cRestSubDelReqFromXapp, 1},
5156 Counter{cSubDelReqToE2, 19},
5157 Counter{cSubDelRespFromE2, 19},
5158 Counter{cRestSubDelRespToXapp, 1},
5161 const subReqCount int = 19
5163 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5164 restSubId := xappConn1.SendRESTSubsReq(t, params)
5165 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5167 assert.Equal(t, len(e2SubsIds), 19)
5169 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5170 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5172 xappConn1.TestMsgChanEmpty(t)
5173 e2termConn1.TestMsgChanEmpty(t)
5174 mainCtrl.wait_registry_empty(t, 10)
5176 mainCtrl.VerifyCounterValues(t)
5179 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
5183 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5184 Counter{cRestSubReqFromXapp, 1},
5185 Counter{cRestSubRespToXapp, 1},
5186 Counter{cSubReqToE2, uint64(subReqCount)},
5187 Counter{cSubRespFromE2, uint64(subReqCount)},
5188 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5189 Counter{cRestSubDelReqFromXapp, 1},
5190 Counter{cSubDelReqToE2, uint64(subReqCount)},
5191 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5192 Counter{cRestSubDelRespToXapp, 1},
5196 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5197 restSubId := xappConn1.SendRESTSubsReq(t, params)
5198 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5200 assert.Equal(t, len(e2SubsIds), subReqCount)
5203 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5204 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5206 xappConn1.TestMsgChanEmpty(t)
5207 e2termConn1.TestMsgChanEmpty(t)
5208 mainCtrl.wait_registry_empty(t, 10)
5210 mainCtrl.VerifyCounterValues(t)
5213 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
5217 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5218 Counter{cRestSubReqFromXapp, 1},
5219 Counter{cRestSubRespToXapp, 1},
5220 Counter{cSubReqToE2, uint64(subReqCount)},
5221 Counter{cSubRespFromE2, uint64(subReqCount)},
5222 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5223 Counter{cRestSubDelReqFromXapp, 1},
5224 Counter{cSubDelReqToE2, uint64(subReqCount)},
5225 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5226 Counter{cRestSubDelRespToXapp, 1},
5230 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5231 restSubId := xappConn1.SendRESTSubsReq(t, params)
5232 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5234 assert.Equal(t, len(e2SubsIds), subReqCount)
5237 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5238 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5240 xappConn1.TestMsgChanEmpty(t)
5241 e2termConn1.TestMsgChanEmpty(t)
5242 mainCtrl.wait_registry_empty(t, 10)
5244 mainCtrl.VerifyCounterValues(t)
5247 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
5251 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5252 Counter{cRestSubReqFromXapp, 1},
5253 Counter{cRestSubRespToXapp, 1},
5254 Counter{cSubReqToE2, uint64(subReqCount)},
5255 Counter{cSubRespFromE2, uint64(subReqCount)},
5256 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5257 Counter{cRestSubDelReqFromXapp, 1},
5258 Counter{cSubDelReqToE2, uint64(subReqCount)},
5259 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5260 Counter{cRestSubDelRespToXapp, 1},
5264 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5265 restSubId := xappConn1.SendRESTSubsReq(t, params)
5266 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5268 assert.Equal(t, len(e2SubsIds), subReqCount)
5271 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5272 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5274 xappConn1.TestMsgChanEmpty(t)
5275 e2termConn1.TestMsgChanEmpty(t)
5276 mainCtrl.wait_registry_empty(t, 10)
5278 mainCtrl.VerifyCounterValues(t)
5281 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
5282 CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
5284 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5285 Counter{cRestSubReqFromXapp, 2},
5286 Counter{cRestSubRespToXapp, 2},
5287 Counter{cSubReqToE2, 2},
5288 Counter{cSubRespFromE2, 2},
5289 Counter{cRestSubNotifToXapp, 2},
5290 Counter{cRestSubDelReqFromXapp, 2},
5291 Counter{cSubDelReqToE2, 2},
5292 Counter{cSubDelRespFromE2, 2},
5293 Counter{cRestSubDelRespToXapp, 2},
5297 var params *teststube2ap.RESTSubsReqParams = nil
5300 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5301 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5303 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5306 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5307 params.SetMeid("RAN_NAME_1")
5308 eventTriggerDefinition := []int64{1234, 1}
5309 params.SetSubEventTriggerDefinition(eventTriggerDefinition)
5311 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5312 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5313 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5314 xappConn2.ExpectRESTNotification(t, restSubId2)
5315 e2termConn1.SendSubsResp(t, crereq, cremsg)
5316 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5318 deleteXapp1Subscription(t, &restSubId1)
5319 deleteXapp2Subscription(t, &restSubId2)
5321 waitSubsCleanup(t, e2SubsId1, 10)
5322 waitSubsCleanup(t, e2SubsId2, 10)
5324 mainCtrl.VerifyCounterValues(t)
5328 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
5329 CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
5331 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5332 Counter{cRestSubReqFromXapp, 2},
5333 Counter{cRestSubRespToXapp, 2},
5334 Counter{cSubReqToE2, 2},
5335 Counter{cSubRespFromE2, 2},
5336 Counter{cRestSubNotifToXapp, 2},
5337 Counter{cRestSubDelReqFromXapp, 2},
5338 Counter{cSubDelReqToE2, 2},
5339 Counter{cSubDelRespFromE2, 2},
5340 Counter{cRestSubDelRespToXapp, 2},
5344 var params *teststube2ap.RESTSubsReqParams = nil
5347 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5348 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5350 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5353 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5354 params.SetMeid("RAN_NAME_1")
5356 actionId := int64(1)
5357 actionType := "report"
5358 actionDefinition := []int64{5678, 1}
5359 subsequestActionType := "continue"
5360 timeToWait := "w10ms"
5361 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
5363 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5364 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5365 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5366 xappConn2.ExpectRESTNotification(t, restSubId2)
5367 e2termConn1.SendSubsResp(t, crereq, cremsg)
5368 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5370 deleteXapp1Subscription(t, &restSubId1)
5371 deleteXapp2Subscription(t, &restSubId2)
5373 waitSubsCleanup(t, e2SubsId1, 10)
5374 waitSubsCleanup(t, e2SubsId2, 10)
5376 mainCtrl.VerifyCounterValues(t)
5380 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
5381 CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
5383 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5384 Counter{cRestSubReqFromXapp, 2},
5385 Counter{cRestSubRespToXapp, 2},
5386 Counter{cSubReqToE2, 2},
5387 Counter{cSubRespFromE2, 2},
5388 Counter{cRestSubNotifToXapp, 2},
5389 Counter{cRestSubDelReqFromXapp, 2},
5390 Counter{cSubDelReqToE2, 2},
5391 Counter{cSubDelRespFromE2, 2},
5392 Counter{cRestSubDelRespToXapp, 2},
5396 var params *teststube2ap.RESTSubsReqParams = nil
5399 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5400 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5402 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5405 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5406 params.SetMeid("RAN_NAME_1")
5407 params.SetSubActionIDs(int64(2))
5409 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5410 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5411 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5412 xappConn2.ExpectRESTNotification(t, restSubId2)
5413 e2termConn1.SendSubsResp(t, crereq, cremsg)
5414 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5416 deleteXapp1Subscription(t, &restSubId1)
5417 deleteXapp2Subscription(t, &restSubId2)
5419 waitSubsCleanup(t, e2SubsId1, 10)
5420 waitSubsCleanup(t, e2SubsId2, 10)
5422 mainCtrl.VerifyCounterValues(t)
5426 func TestRESTSubReqDiffActionType(t *testing.T) {
5427 CaseBegin("TestRESTSubReqDiffActionType")
5429 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5430 Counter{cRestSubReqFromXapp, 2},
5431 Counter{cRestSubRespToXapp, 2},
5432 Counter{cSubReqToE2, 2},
5433 Counter{cSubRespFromE2, 2},
5434 Counter{cRestSubNotifToXapp, 2},
5435 Counter{cRestSubDelReqFromXapp, 2},
5436 Counter{cSubDelReqToE2, 2},
5437 Counter{cSubDelRespFromE2, 2},
5438 Counter{cRestSubDelRespToXapp, 2},
5441 const e2Timeout int64 = 2
5442 const e2RetryCount int64 = 2
5443 const routingNeeded bool = true
5446 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5447 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5450 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5451 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5453 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5456 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5457 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5458 params.SetMeid("RAN_NAME_1")
5460 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5461 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5462 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5463 xappConn2.ExpectRESTNotification(t, restSubId2)
5464 e2termConn1.SendSubsResp(t, crereq, cremsg)
5465 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5467 deleteXapp1Subscription(t, &restSubId1)
5468 deleteXapp2Subscription(t, &restSubId2)
5470 waitSubsCleanup(t, e2SubsId1, 10)
5471 waitSubsCleanup(t, e2SubsId2, 10)
5473 mainCtrl.VerifyCounterValues(t)
5477 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
5478 CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
5480 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5481 Counter{cRestSubReqFromXapp, 2},
5482 Counter{cRestSubRespToXapp, 2},
5483 Counter{cSubReqToE2, 2},
5484 Counter{cSubRespFromE2, 2},
5485 Counter{cRestSubNotifToXapp, 2},
5486 Counter{cRestSubDelReqFromXapp, 2},
5487 Counter{cSubDelReqToE2, 2},
5488 Counter{cSubDelRespFromE2, 2},
5489 Counter{cRestSubDelRespToXapp, 2},
5492 const e2Timeout int64 = 2
5493 const e2RetryCount int64 = 2
5494 const routingNeeded bool = true
5497 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5498 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5501 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5502 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5504 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5507 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
5508 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5509 params.SetMeid("RAN_NAME_1")
5511 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5512 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5513 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5514 xappConn2.ExpectRESTNotification(t, restSubId2)
5515 e2termConn1.SendSubsResp(t, crereq, cremsg)
5516 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5518 deleteXapp1Subscription(t, &restSubId1)
5519 deleteXapp2Subscription(t, &restSubId2)
5521 waitSubsCleanup(t, e2SubsId1, 10)
5522 waitSubsCleanup(t, e2SubsId2, 10)
5524 mainCtrl.VerifyCounterValues(t)
5528 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
5529 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
5531 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5532 Counter{cRestSubReqFromXapp, 2},
5533 Counter{cRestSubRespToXapp, 2},
5534 Counter{cSubReqToE2, 2},
5535 Counter{cSubRespFromE2, 2},
5536 Counter{cRestSubNotifToXapp, 2},
5537 Counter{cRestSubDelReqFromXapp, 2},
5538 Counter{cSubDelReqToE2, 2},
5539 Counter{cSubDelRespFromE2, 2},
5540 Counter{cRestSubDelRespToXapp, 2},
5544 var params *teststube2ap.RESTSubsReqParams = nil
5547 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5548 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5550 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5553 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5554 params.SetMeid("RAN_NAME_1")
5555 actionDefinition := []int64{5678, 1}
5556 params.SetSubActionDefinition(actionDefinition)
5558 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5559 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5560 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5561 xappConn2.ExpectRESTNotification(t, restSubId2)
5562 e2termConn1.SendSubsResp(t, crereq, cremsg)
5563 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5565 deleteXapp1Subscription(t, &restSubId1)
5566 deleteXapp2Subscription(t, &restSubId2)
5568 waitSubsCleanup(t, e2SubsId1, 10)
5569 waitSubsCleanup(t, e2SubsId2, 10)
5571 mainCtrl.VerifyCounterValues(t)
5575 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
5576 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
5578 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5579 Counter{cRestSubReqFromXapp, 2},
5580 Counter{cRestSubRespToXapp, 2},
5581 Counter{cSubReqToE2, 2},
5582 Counter{cSubRespFromE2, 2},
5583 Counter{cRestSubNotifToXapp, 2},
5584 Counter{cRestSubDelReqFromXapp, 2},
5585 Counter{cSubDelReqToE2, 2},
5586 Counter{cSubDelRespFromE2, 2},
5587 Counter{cRestSubDelRespToXapp, 2},
5591 var params *teststube2ap.RESTSubsReqParams = nil
5594 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5595 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5597 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5600 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5601 params.SetMeid("RAN_NAME_1")
5602 actionDefinition := []int64{56782}
5603 params.SetSubActionDefinition(actionDefinition)
5605 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5606 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5607 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5608 xappConn2.ExpectRESTNotification(t, restSubId2)
5609 e2termConn1.SendSubsResp(t, crereq, cremsg)
5610 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5612 deleteXapp1Subscription(t, &restSubId1)
5613 deleteXapp2Subscription(t, &restSubId2)
5615 waitSubsCleanup(t, e2SubsId1, 10)
5616 waitSubsCleanup(t, e2SubsId2, 10)
5618 mainCtrl.VerifyCounterValues(t)
5622 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
5623 CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
5625 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5626 Counter{cRestSubReqFromXapp, 2},
5627 Counter{cRestSubRespToXapp, 2},
5628 Counter{cSubReqToE2, 2},
5629 Counter{cSubRespFromE2, 2},
5630 Counter{cRestSubNotifToXapp, 2},
5631 Counter{cRestSubDelReqFromXapp, 2},
5632 Counter{cSubDelReqToE2, 2},
5633 Counter{cSubDelRespFromE2, 2},
5634 Counter{cRestSubDelRespToXapp, 2},
5638 var params *teststube2ap.RESTSubsReqParams = nil
5641 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5642 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5644 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5647 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5648 params.SetMeid("RAN_NAME_1")
5649 params.SetTimeToWait("w200ms")
5650 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5651 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5652 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5653 xappConn2.ExpectRESTNotification(t, restSubId2)
5654 e2termConn1.SendSubsResp(t, crereq, cremsg)
5655 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5657 deleteXapp1Subscription(t, &restSubId1)
5658 deleteXapp2Subscription(t, &restSubId2)
5660 waitSubsCleanup(t, e2SubsId1, 10)
5661 waitSubsCleanup(t, e2SubsId2, 10)
5663 mainCtrl.VerifyCounterValues(t)
5667 //-----------------------------------------------------------------------------
5668 // TestRESTUnpackSubscriptionResponseDecodeFail
5671 // +-------+ +---------+ +---------+
5672 // | xapp | | submgr | | e2term |
5673 // +-------+ +---------+ +---------+
5676 // |---------------->| |
5678 // | RESTSubResp | |
5679 // |<----------------| |
5682 // | |------------->|
5684 // | | SubResp | ASN.1 decode fails
5685 // | |<-------------|
5688 // | |------------->|
5690 // | | SubFail | Duplicated action
5691 // | |<-------------|
5692 // | RESTNotif (fail)| |
5693 // |<----------------| |
5695 // | |------------->|
5698 // | |<-------------|
5700 //-----------------------------------------------------------------------------
5702 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
5703 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
5704 const subReqCount int = 1
5707 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5708 restSubId := xappConn1.SendRESTSubsReq(t, params)
5710 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5711 // Decode of this response fails which will result resending original request
5712 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
5714 _, cremsg = e2termConn1.RecvSubsReq(t)
5716 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
5718 // Subscription already created in E2 Node.
5719 fparams := &teststube2ap.E2StubSubsFailParams{}
5721 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5722 e2termConn1.SendSubsFail(t, fparams, cremsg)
5724 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5725 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5727 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5728 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5730 // Wait that subs is cleaned
5731 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5733 xappConn1.TestMsgChanEmpty(t)
5734 e2termConn1.TestMsgChanEmpty(t)
5735 mainCtrl.wait_registry_empty(t, 10)
5738 //-----------------------------------------------------------------------------
5739 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
5742 // +-------+ +---------+ +---------+
5743 // | xapp | | submgr | | e2term |
5744 // +-------+ +---------+ +---------+
5747 // |---------------->| |
5749 // | RESTSubResp | |
5750 // |<----------------| |
5753 // | |------------->|
5755 // | | SubResp | Unknown instanceId
5756 // | |<-------------|
5759 // | |------------->|
5761 // | | SubFail | Duplicated action
5762 // | |<-------------|
5763 // | RESTNotif (fail)| |
5764 // |<----------------| |
5766 // | |------------->|
5769 // | |<-------------|
5771 //-----------------------------------------------------------------------------
5773 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
5774 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
5775 const subReqCount int = 1
5778 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5779 restSubId := xappConn1.SendRESTSubsReq(t, params)
5781 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5783 // Unknown instanceId in this response which will result resending original request
5784 orgInstanceId := crereq.RequestId.InstanceId
5785 crereq.RequestId.InstanceId = 0
5786 e2termConn1.SendSubsResp(t, crereq, cremsg)
5788 _, cremsg = e2termConn1.RecvSubsReq(t)
5790 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
5792 // Subscription already created in E2 Node.
5793 fparams := &teststube2ap.E2StubSubsFailParams{}
5795 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5796 e2termConn1.SendSubsFail(t, fparams, cremsg)
5798 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5799 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5801 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5802 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5804 // Wait that subs is cleaned
5805 mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
5807 xappConn1.TestMsgChanEmpty(t)
5808 e2termConn1.TestMsgChanEmpty(t)
5809 mainCtrl.wait_registry_empty(t, 10)
5812 //-----------------------------------------------------------------------------
5813 // TestRESTUnpackSubscriptionResponseNoTransaction
5816 // +-------+ +---------+ +---------+
5817 // | xapp | | submgr | | e2term |
5818 // +-------+ +---------+ +---------+
5821 // |---------------->| |
5823 // | RESTSubResp | |
5824 // |<----------------| |
5827 // | |------------->|
5829 // | | SubResp | No transaction for the response
5830 // | |<-------------|
5833 // | |------------->|
5835 // | | SubFail | Duplicated action
5836 // | |<-------------|
5837 // | RESTNotif (fail)| |
5838 // |<----------------| |
5840 // | |------------->|
5843 // | |<-------------|
5846 // | |------------->|
5849 // | |<-------------|
5851 //-----------------------------------------------------------------------------
5852 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
5853 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
5854 const subReqCount int = 1
5857 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5858 restSubId := xappConn1.SendRESTSubsReq(t, params)
5860 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5862 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
5863 // No transaction exist for this response which will result resending original request
5864 e2termConn1.SendSubsResp(t, crereq, cremsg)
5866 _, cremsg = e2termConn1.RecvSubsReq(t)
5868 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
5870 // Subscription already created in E2 Node.
5871 fparams := &teststube2ap.E2StubSubsFailParams{}
5873 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5874 e2termConn1.SendSubsFail(t, fparams, cremsg)
5876 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5877 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5879 // Resending happens because there no transaction
5880 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5881 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5883 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5884 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5886 // Wait that subs is cleaned
5887 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5889 xappConn1.TestMsgChanEmpty(t)
5890 e2termConn1.TestMsgChanEmpty(t)
5891 mainCtrl.wait_registry_empty(t, 10)
5895 //-----------------------------------------------------------------------------
5896 // TestRESTUnpackSubscriptionFailureDecodeFail
5899 // +-------+ +---------+ +---------+
5900 // | xapp | | submgr | | e2term |
5901 // +-------+ +---------+ +---------+
5904 // |---------------->| |
5906 // | RESTSubResp | |
5907 // |<----------------| |
5910 // | |------------->|
5912 // | | SubFail | ASN.1 decode fails
5913 // | |<-------------|
5916 // | |------------->|
5918 // | | SubFail | Duplicated action
5919 // | |<-------------|
5920 // | RESTNotif (fail)| |
5921 // |<----------------| |
5923 // | |------------->|
5926 // | |<-------------|
5928 //-----------------------------------------------------------------------------
5929 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
5930 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
5931 const subReqCount int = 1
5934 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5935 restSubId := xappConn1.SendRESTSubsReq(t, params)
5937 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5939 // Decode of this response fails which will result resending original request
5940 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
5942 _, cremsg = e2termConn1.RecvSubsReq(t)
5944 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
5946 // Subscription already created in E2 Node.
5947 fparams := &teststube2ap.E2StubSubsFailParams{}
5949 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5950 e2termConn1.SendSubsFail(t, fparams, cremsg)
5952 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5953 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5955 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5956 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5958 // Wait that subs is cleaned
5959 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5961 xappConn1.TestMsgChanEmpty(t)
5962 e2termConn1.TestMsgChanEmpty(t)
5963 mainCtrl.wait_registry_empty(t, 10)
5966 //-----------------------------------------------------------------------------
5967 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
5970 // +-------+ +---------+ +---------+
5971 // | xapp | | submgr | | e2term |
5972 // +-------+ +---------+ +---------+
5975 // |---------------->| |
5977 // | RESTSubResp | |
5978 // |<----------------| |
5981 // | |------------->|
5983 // | | SubFail | Unknown instanceId
5984 // | |<-------------|
5987 // | |------------->|
5989 // | | SubFail | Duplicated action
5990 // | |<-------------|
5991 // | RESTNotif (fail)| |
5992 // |<----------------| |
5994 // | |------------->|
5997 // | |<-------------|
5999 //-----------------------------------------------------------------------------
6000 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
6001 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
6002 const subReqCount int = 1
6005 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6006 restSubId := xappConn1.SendRESTSubsReq(t, params)
6008 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6010 // Unknown instanceId in this response which will result resending original request
6011 fparams := &teststube2ap.E2StubSubsFailParams{}
6013 fparams.Fail.RequestId.InstanceId = 0
6014 e2termConn1.SendSubsFail(t, fparams, cremsg)
6016 _, cremsg = e2termConn1.RecvSubsReq(t)
6018 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6020 // Subscription already created in E2 Node.
6021 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6022 e2termConn1.SendSubsFail(t, fparams, cremsg)
6024 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6025 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6027 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6028 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6030 // Wait that subs is cleaned
6031 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6033 xappConn1.TestMsgChanEmpty(t)
6034 e2termConn1.TestMsgChanEmpty(t)
6035 mainCtrl.wait_registry_empty(t, 10)
6038 //-----------------------------------------------------------------------------
6039 // TestRESTUnpackSubscriptionFailureNoTransaction
6042 // +-------+ +---------+ +---------+
6043 // | xapp | | submgr | | e2term |
6044 // +-------+ +---------+ +---------+
6047 // |---------------->| |
6049 // | RESTSubResp | |
6050 // |<----------------| |
6053 // | |------------->|
6055 // | | SubFail | No transaction for the response
6056 // | |<-------------|
6059 // | |------------->|
6061 // | | SubFail | Duplicated action
6062 // | |<-------------|
6063 // | RESTNotif (fail)| |
6064 // |<----------------| |
6066 // | |------------->|
6069 // | |<-------------|
6071 //-----------------------------------------------------------------------------
6072 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
6073 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
6074 const subReqCount int = 1
6077 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6078 restSubId := xappConn1.SendRESTSubsReq(t, params)
6080 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6082 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6084 // No transaction exist for this response which will result resending original request
6085 fparams := &teststube2ap.E2StubSubsFailParams{}
6087 e2termConn1.SendSubsFail(t, fparams, cremsg)
6089 _, cremsg = e2termConn1.RecvSubsReq(t)
6091 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6093 // Subscription already created in E2 Node.
6094 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6095 e2termConn1.SendSubsFail(t, fparams, cremsg)
6097 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6098 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6100 // Resending happens because there no transaction
6101 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6102 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6104 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6105 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6107 // Wait that subs is cleaned
6108 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6110 xappConn1.TestMsgChanEmpty(t)
6111 e2termConn1.TestMsgChanEmpty(t)
6112 mainCtrl.wait_registry_empty(t, 10)
6115 //-----------------------------------------------------------------------------
6116 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
6119 // +-------+ +---------+ +---------+
6120 // | xapp | | submgr | | e2term |
6121 // +-------+ +---------+ +---------+
6123 // | [SUBS CREATE] |
6126 // | RESTSubDelReq | |
6127 // |---------------->| |
6129 // | RESTSubDelResp | |
6130 // |<----------------| |
6133 // | |------------->|
6135 // | | SubDelResp | ASN.1 decode fails
6136 // | |<-------------|
6139 // | |------------->|
6141 // | | SubDelFail | Subscription does exist any more
6142 // | |<-------------|
6145 //-----------------------------------------------------------------------------
6146 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
6147 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail")
6150 var params *teststube2ap.RESTSubsReqParams = nil
6151 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6154 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6156 // E2t: Receive 1st SubsDelReq
6157 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6159 // Decode of this response fails which will result resending original request
6160 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_REQ)
6162 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6163 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6165 // Subscription does not exist in in E2 Node.
6166 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6168 // Wait that subs is cleaned
6169 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6171 xappConn1.TestMsgChanEmpty(t)
6172 e2termConn1.TestMsgChanEmpty(t)
6173 mainCtrl.wait_registry_empty(t, 10)
6176 //-----------------------------------------------------------------------------
6177 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
6180 // +-------+ +---------+ +---------+
6181 // | xapp | | submgr | | e2term |
6182 // +-------+ +---------+ +---------+
6184 // | [SUBS CREATE] |
6187 // | RESTSubDelReq | |
6188 // |---------------->| |
6190 // | RESTSubDelResp | |
6191 // |<----------------| |
6194 // | |------------->|
6196 // | | SubDelResp | Unknown instanceId
6197 // | |<-------------|
6200 // | |------------->|
6202 // | | SubDelFail | Subscription does exist any more
6203 // | |<-------------|
6205 //-----------------------------------------------------------------------------
6206 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
6207 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId")
6210 var params *teststube2ap.RESTSubsReqParams = nil
6211 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6214 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6216 // E2t: Receive 1st SubsDelReq
6217 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6219 // Unknown instanceId in this response which will result resending original request
6220 delreq.RequestId.InstanceId = 0
6221 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6223 // E2t: Receive 2nd SubsDelReq
6224 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6226 // Subscription does not exist in in E2 Node.
6227 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6229 // Wait that subs is cleaned
6230 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6232 xappConn1.TestMsgChanEmpty(t)
6233 e2termConn1.TestMsgChanEmpty(t)
6234 mainCtrl.wait_registry_empty(t, 10)
6237 //-----------------------------------------------------------------------------
6238 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
6241 // +-------+ +---------+ +---------+
6242 // | xapp | | submgr | | e2term |
6243 // +-------+ +---------+ +---------+
6245 // | [SUBS CREATE] |
6248 // | RESTSubDelReq | |
6249 // |---------------->| |
6251 // | RESTSubDelResp | |
6252 // |<----------------| |
6255 // | |------------->|
6257 // | | SubDelResp | No transaction for the response
6258 // | |<-------------|
6261 // | |------------->|
6263 // | | SubDelFail | Subscription does exist any more
6264 // | |<-------------|
6266 //-----------------------------------------------------------------------------
6267 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
6268 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction")
6271 var params *teststube2ap.RESTSubsReqParams = nil
6272 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6275 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6277 // E2t: Receive 1st SubsDelReq
6278 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6280 mainCtrl.MakeTransactionNil(t, e2SubsId)
6282 // No transaction exist for this response which will result resending original request
6283 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6285 // E2t: Receive 2nd SubsDelReq
6286 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6288 // Subscription does not exist in in E2 Node.
6289 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6291 // Wait that subs is cleaned
6292 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6294 xappConn1.TestMsgChanEmpty(t)
6295 e2termConn1.TestMsgChanEmpty(t)
6296 mainCtrl.wait_registry_empty(t, 10)
6299 //-----------------------------------------------------------------------------
6300 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
6303 // +-------+ +---------+ +---------+
6304 // | xapp | | submgr | | e2term |
6305 // +-------+ +---------+ +---------+
6307 // | [SUBS CREATE] |
6310 // | RESTSubDelReq | |
6311 // |---------------->| |
6313 // | RESTSubDelResp | |
6314 // |<----------------| |
6317 // | |------------->|
6319 // | | SubDelFail | ASN.1 decode fails
6320 // | |<-------------|
6323 // | |------------->|
6325 // | | SubDelFail | Subscription does exist any more
6326 // | |<-------------|
6328 //-----------------------------------------------------------------------------
6329 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
6330 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail")
6333 var params *teststube2ap.RESTSubsReqParams = nil
6334 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6337 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6339 // E2t: Receive 1st SubsDelReq
6340 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6342 // Decode of this response fails which will result resending original request
6343 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
6345 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6346 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6348 // Subscription does not exist in in E2 Node.
6349 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6351 // Wait that subs is cleaned
6352 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6354 xappConn1.TestMsgChanEmpty(t)
6355 e2termConn1.TestMsgChanEmpty(t)
6356 mainCtrl.wait_registry_empty(t, 10)
6359 //-----------------------------------------------------------------------------
6360 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
6363 // +-------+ +---------+ +---------+
6364 // | xapp | | submgr | | e2term |
6365 // +-------+ +---------+ +---------+
6367 // | [SUBS CREATE] |
6370 // | RESTSubDelReq | |
6371 // |---------------->| |
6373 // | RESTSubDelResp | |
6374 // |<----------------| |
6377 // | |------------->|
6379 // | | SubDelFail | Unknown instanceId
6380 // | |<-------------|
6383 // | |------------->|
6385 // | | SubDelFail | Subscription does exist any more
6386 // | |<-------------|
6388 //-----------------------------------------------------------------------------
6389 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
6390 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId")
6393 var params *teststube2ap.RESTSubsReqParams = nil
6394 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6397 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6399 // E2t: Receive 1st SubsDelReq
6400 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6402 // Unknown instanceId in this response which will result resending original request
6403 delreq.RequestId.InstanceId = 0
6404 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6406 // E2t: Receive 2nd SubsDelReq
6407 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6409 // Subscription does not exist in in E2 Node.
6410 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6412 // Wait that subs is cleaned
6413 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6415 xappConn1.TestMsgChanEmpty(t)
6416 e2termConn1.TestMsgChanEmpty(t)
6417 mainCtrl.wait_registry_empty(t, 10)
6420 //-----------------------------------------------------------------------------
6421 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
6424 // +-------+ +---------+ +---------+
6425 // | xapp | | submgr | | e2term |
6426 // +-------+ +---------+ +---------+
6428 // | [SUBS CREATE] |
6431 // | RESTSubDelReq | |
6432 // |---------------->| |
6434 // | RESTSubDelResp | |
6435 // |<----------------| |
6438 // | |------------->|
6440 // | | SubDelFail | No transaction for the response
6441 // | |<-------------|
6444 // | |------------->|
6446 // | | SubDelFail | Subscription does exist any more
6447 // | |<-------------|
6449 //-----------------------------------------------------------------------------
6450 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
6451 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction")
6454 var params *teststube2ap.RESTSubsReqParams = nil
6455 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6458 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6460 // E2t: Receive 1st SubsDelReq
6461 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6463 mainCtrl.MakeTransactionNil(t, e2SubsId)
6465 // No transaction exist for this response which will result resending original request
6466 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6468 // E2t: Receive 2nd SubsDelReq
6469 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6471 // Subscription does not exist in in E2 Node.
6472 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6474 // Wait that subs is cleaned
6475 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6477 xappConn1.TestMsgChanEmpty(t)
6478 e2termConn1.TestMsgChanEmpty(t)
6479 mainCtrl.wait_registry_empty(t, 10)
6482 //-----------------------------------------------------------------------------
6483 // TestRESTSubReqFailAsn1PackSubReqError
6486 // +-------+ +---------+ +---------+
6487 // | xapp | | submgr | | e2term |
6488 // +-------+ +---------+ +---------+
6491 // |---------------->| |
6493 // | RESTSubResp | |
6494 // |<----------------| |
6496 // | ASN.1 encode fails |
6499 // | |------------->|
6502 // | |<-------------|
6506 // |<----------------| |
6508 // | [SUBS DELETE] |
6511 //-----------------------------------------------------------------------------
6512 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
6514 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6515 Counter{cRestSubReqFromXapp, 1},
6516 Counter{cRestSubRespToXapp, 1},
6517 Counter{cRestSubFailNotifToXapp, 1},
6520 const subReqCount int = 1
6522 var params *teststube2ap.RESTSubsReqParams = nil
6523 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
6524 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
6527 restSubId := xappConn1.SendRESTSubsReq(t, params)
6528 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
6530 // E2t: Receive SubsDelReq
6531 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6533 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6534 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
6536 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
6537 // Wait that subs is cleaned
6538 waitSubsCleanup(t, e2SubsId, 10)
6539 mainCtrl.VerifyCounterValues(t)
6542 func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
6543 CaseBegin("TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction")
6545 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6546 Counter{cRestSubReqFromXapp, 2},
6547 Counter{cRestSubRespToXapp, 2},
6548 Counter{cSubReqToE2, 2},
6549 Counter{cSubRespFromE2, 1},
6550 Counter{cRestSubNotifToXapp, 1},
6551 Counter{cRestSubFailNotifToXapp, 1},
6552 Counter{cRestSubDelReqFromXapp, 1},
6553 Counter{cSubDelReqToE2, 1},
6554 Counter{cSubDelRespFromE2, 1},
6555 Counter{cRestSubDelRespToXapp, 1},
6558 const e2Timeout int64 = 1
6559 const e2RetryCount int64 = 0
6560 const routingNeeded bool = false
6563 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6564 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6567 restSubId := xappConn1.SendRESTSubsReq(t, params)
6568 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6570 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6571 xappConn1.ExpectRESTNotification(t, restSubId)
6572 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
6573 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6574 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
6577 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6578 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6579 params.SetSubscriptionID(&restSubId)
6580 params.SetTimeToWait("w200ms")
6581 restSubId = xappConn1.SendRESTSubsReq(t, params)
6582 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6584 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
6585 xappConn1.ExpectRESTNotification(t, restSubId)
6586 // SubsResp is missing
6587 e2SubsId = xappConn1.WaitRESTNotification(t, restSubId)
6588 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
6591 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6592 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6593 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6595 waitSubsCleanup(t, e2SubsId, 10)
6597 mainCtrl.VerifyCounterValues(t)
6600 //-----------------------------------------------------------------------------
6601 // TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle
6604 // +-------+ +---------+ +---------+
6605 // | xapp | | submgr | | e2term |
6606 // +-------+ +---------+ +---------+
6609 // |---------------->| |
6611 // | RESTSubResp | |
6612 // |<----------------| |
6614 // | |------------->|
6617 // | |<-------------|
6620 // |<----------------| |
6623 // |---------------->| |
6625 // | RESTSubResp | |
6626 // |<----------------| |
6628 // | |------------->|
6630 // | Submgr restart |
6632 // | RESTSubDelReq | |
6633 // |---------------->| |
6636 // | |------------->|
6639 // | |<-------------|
6641 // | RESTSubDelResp | |
6642 // |<----------------| |
6644 //-----------------------------------------------------------------------------
6646 func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
6647 CaseBegin("TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle")
6649 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6650 Counter{cRestSubReqFromXapp, 2},
6651 Counter{cRestSubRespToXapp, 2},
6652 Counter{cSubReqToE2, 2},
6653 Counter{cSubRespFromE2, 1},
6654 Counter{cRestSubNotifToXapp, 1},
6655 Counter{cRestSubNotifToXapp, 1},
6656 Counter{cRestSubDelReqFromXapp, 1},
6657 Counter{cSubDelReqToE2, 1},
6658 Counter{cRestSubDelRespToXapp, 1},
6661 // Remove possible existing subscription
6662 mainCtrl.removeExistingSubscriptions(t)
6664 const e2Timeout int64 = 1
6665 const e2RetryCount int64 = 0
6666 const routingNeeded bool = false
6669 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6670 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6671 // Create subscription
6672 restSubId := xappConn1.SendRESTSubsReq(t, params)
6673 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6675 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6676 xappConn1.ExpectRESTNotification(t, restSubId)
6677 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
6678 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6679 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
6681 // Check subscription
6682 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
6685 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6686 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6687 params.SetSubscriptionID(&restSubId)
6688 params.SetTimeToWait("w200ms")
6689 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
6690 restSubId = xappConn1.SendRESTSubsReq(t, params)
6691 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6693 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
6694 mainCtrl.SetResetTestFlag(t, false)
6696 // SubsResp is missing due to submgr restart
6698 mainCtrl.SimulateRestart(t)
6699 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
6701 // Check subscription
6702 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
6704 xapp.Logger.Debug("Here 1")
6705 //<-time.After(3 * time.Second)
6706 xapp.Logger.Debug("Here 2")
6708 // Delete subscription
6709 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6710 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6711 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6713 //Wait that subs is cleaned
6714 waitSubsCleanup(t, e2SubsId, 10)
6716 mainCtrl.VerifyCounterValues(t)
6719 ////////////////////////////////////////////////////////////////////////////////////
6720 // Services for UT cases
6721 ////////////////////////////////////////////////////////////////////////////////////
6722 const subReqCount int = 1
6723 const host string = "localhost"
6725 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
6727 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
6729 restSubId := fromXappConn.SendRESTSubsReq(t, params)
6730 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
6732 crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
6733 fromXappConn.ExpectRESTNotification(t, restSubId)
6734 toE2termConn.SendSubsResp(t, crereq1, cremsg1)
6735 e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
6736 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
6738 return restSubId, e2SubsId
6741 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
6743 params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
6745 params.SetMeid(meid)
6747 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
6748 restSubId := xappConn2.SendRESTSubsReq(t, params)
6749 xappConn2.ExpectRESTNotification(t, restSubId)
6750 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
6751 e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
6752 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
6754 return restSubId, e2SubsId
6757 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
6759 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6760 restSubId := xappConn1.SendRESTSubsReq(t, params)
6761 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
6763 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6764 xappConn1.ExpectRESTNotification(t, restSubId)
6765 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
6766 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6767 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
6769 return restSubId, e2SubsId
6772 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
6773 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6774 restSubId := xappConn1.SendRESTSubsReq(t, params)
6776 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6777 fparams1 := &teststube2ap.E2StubSubsFailParams{}
6778 fparams1.Set(crereq1)
6779 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
6781 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
6782 xappConn1.ExpectRESTNotification(t, restSubId)
6783 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
6784 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6785 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
6787 return restSubId, e2SubsId
6790 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
6791 fromXappConn.SendRESTSubsDelReq(t, restSubId)
6792 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
6793 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
6796 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
6797 xappConn1.SendRESTSubsDelReq(t, restSubId)
6798 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6799 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6802 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
6803 xappConn2.SendRESTSubsDelReq(t, restSubId)
6804 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6805 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6808 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
6809 resp, _ := xapp.Subscription.QuerySubscriptions()
6810 assert.Equal(t, resp[0].SubscriptionID, e2SubsId)
6811 assert.Equal(t, resp[0].Meid, meid)
6812 assert.Equal(t, resp[0].ClientEndpoint, endpoint)
6815 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
6816 //Wait that subs is cleaned
6817 mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
6819 xappConn1.TestMsgChanEmpty(t)
6820 xappConn2.TestMsgChanEmpty(t)
6821 e2termConn1.TestMsgChanEmpty(t)
6822 mainCtrl.wait_registry_empty(t, timeout)
6825 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
6827 var e2SubsId []uint32
6829 for i := 0; i < count; i++ {
6830 xapp.Logger.Debug("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
6831 crereq, cremsg := toE2termConn.RecvSubsReq(t)
6832 fromXappConn.ExpectRESTNotification(t, restSubId)
6833 toE2termConn.SendSubsResp(t, crereq, cremsg)
6834 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
6835 e2SubsId = append(e2SubsId, instanceId)
6836 xapp.Logger.Debug("TEST: %v", e2SubsId)
6837 xapp.Logger.Debug("TEST: %d ===================================== END CRE ============================================", i+1)
6838 <-time.After(100 * time.Millisecond)
6843 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
6845 for i := 0; i < len(e2SubsIds); i++ {
6846 xapp.Logger.Debug("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
6847 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
6848 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
6849 <-time.After(1 * time.Second)
6850 xapp.Logger.Debug("TEST: %d ===================================== END DEL ============================================", i+1)
6851 <-time.After(100 * time.Millisecond)
6854 // Wait that subs is cleaned
6855 for i := 0; i < len(e2SubsIds); i++ {
6856 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)