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 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2138 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2140 // Wait that subs is cleaned
2141 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2143 xappConn1.TestMsgChanEmpty(t)
2144 xappConn2.TestMsgChanEmpty(t)
2145 e2termConn1.TestMsgChanEmpty(t)
2146 mainCtrl.wait_registry_empty(t, 10)
2149 //-----------------------------------------------------------------------------
2150 // TestSubReqAndSubDelOkWithRestartInMiddle
2153 // +-------+ +---------+ +---------+
2154 // | xapp | | submgr | | e2term |
2155 // +-------+ +---------+ +---------+
2158 // |------------->| |
2161 // | |------------->|
2164 // | |<-------------|
2167 // |<-------------| |
2170 // | Submgr restart |
2173 // |------------->| |
2176 // | |------------->|
2179 // | |<-------------|
2182 // |<-------------| |
2184 //-----------------------------------------------------------------------------
2186 func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
2187 CaseBegin("TestSubReqAndSubDelOkWithRestartInMiddle")
2189 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2190 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2191 e2termConn1.SendSubsResp(t, crereq, cremsg)
2192 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2194 // Check subscription
2195 resp, _ := xapp.Subscription.QuerySubscriptions()
2196 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2197 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2198 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2200 mainCtrl.SimulateRestart(t)
2201 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2203 // Check that subscription is restored correctly after restart
2204 resp, _ = xapp.Subscription.QuerySubscriptions()
2205 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2206 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2207 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2209 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2210 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2211 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2212 xappConn1.RecvSubsDelResp(t, deltrans)
2214 //Wait that subs is cleaned
2215 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2217 xappConn1.TestMsgChanEmpty(t)
2218 xappConn2.TestMsgChanEmpty(t)
2219 e2termConn1.TestMsgChanEmpty(t)
2220 mainCtrl.wait_registry_empty(t, 10)
2223 //-----------------------------------------------------------------------------
2224 // TestSubReqAndSubDelOkSameActionWithRestartsInMiddle
2227 // +-------+ +-------+ +---------+ +---------+
2228 // | xapp2 | | xapp1 | | submgr | | e2term |
2229 // +-------+ +-------+ +---------+ +---------+
2234 // | |------------->| |
2237 // | | |------------->|
2239 // | | |<-------------|
2241 // | |<-------------| |
2244 // | submgr restart |
2249 // |--------------------------->| |
2252 // |<---------------------------| |
2254 // | | SubDelReq 1 | |
2255 // | |------------->| |
2257 // | | SubDelResp 1 | |
2258 // | |<-------------| |
2262 // | submgr restart |
2265 // | SubDelReq 2 | |
2266 // |--------------------------->| |
2268 // | | | SubDelReq 2 |
2269 // | | |------------->|
2271 // | | | SubDelReq 2 |
2272 // | | |------------->|
2274 // | SubDelResp 2 | |
2275 // |<---------------------------| |
2277 //-----------------------------------------------------------------------------
2279 func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
2280 CaseBegin("TestSubReqAndSubDelOkSameActionWithRestartsInMiddle")
2283 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2285 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2286 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2287 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2288 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2291 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2293 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2294 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
2296 // Check subscription
2297 resp, _ := xapp.Subscription.QuerySubscriptions() ////////////////////////////////
2298 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2299 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2300 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2302 mainCtrl.SimulateRestart(t)
2303 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2305 // Check that subscription is restored correctly after restart
2306 resp, _ = xapp.Subscription.QuerySubscriptions()
2307 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2308 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2309 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2312 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2313 xapp.Logger.Debug("xappConn1.RecvSubsDelResp")
2314 xappConn1.RecvSubsDelResp(t, deltrans1)
2315 xapp.Logger.Debug("xappConn1.RecvSubsDelResp received")
2317 mainCtrl.SimulateRestart(t)
2318 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2321 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
2322 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2324 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2325 xappConn2.RecvSubsDelResp(t, deltrans2)
2327 //Wait that subs is cleaned
2328 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2330 xappConn1.TestMsgChanEmpty(t)
2331 xappConn2.TestMsgChanEmpty(t)
2332 e2termConn1.TestMsgChanEmpty(t)
2333 mainCtrl.wait_registry_empty(t, 10)
2336 //*****************************************************************************
2337 // REST interface test cases
2338 //*****************************************************************************
2340 //-----------------------------------------------------------------------------
2341 // Test debug GET and POST requests
2344 // +-------+ +---------+
2345 // | user | | submgr |
2346 // +-------+ +---------+
2353 func TestGetSubscriptions(t *testing.T) {
2355 mainCtrl.sendGetRequest(t, "localhost:8088", "/ric/v1/subscriptions")
2358 func TestGetSymptomData(t *testing.T) {
2360 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/symptomdata")
2363 func TestPostdeleteSubId(t *testing.T) {
2365 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/deletesubid=1")
2368 func TestPostEmptyDb(t *testing.T) {
2370 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/emptydb")
2373 //-----------------------------------------------------------------------------
2374 // TestRESTSubReqAndRouteNok
2377 // +-------+ +---------+ +---------+
2378 // | xapp | | submgr | | rtmgr |
2379 // +-------+ +---------+ +---------+
2382 // |---------------->| |
2384 // | RESTSubResp | |
2385 // |<----------------| |
2386 // | | RouteCreate |
2387 // | |------------->|
2389 // | | RouteCreate |
2391 // | |(Bad request) |
2392 // | |<-------------|
2394 // |<----------------| |
2396 // | [SUBS INT DELETE] |
2398 // | RESTSubDelReq | |
2399 // |---------------->| |
2400 // | RESTSubDelResp | |
2401 // |<----------------| |
2403 //-----------------------------------------------------------------------------
2404 func TestRESTSubReqAndRouteNok(t *testing.T) {
2405 CaseBegin("TestRESTSubReqAndRouteNok")
2407 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2408 Counter{cRestSubReqFromXapp, 1},
2409 Counter{cRestSubRespToXapp, 1},
2410 Counter{cRouteCreateFail, 1},
2411 Counter{cRestSubFailNotifToXapp, 1},
2412 Counter{cRestSubDelReqFromXapp, 1},
2413 Counter{cRestSubDelRespToXapp, 1},
2416 const subReqCount int = 1
2417 // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
2418 waiter := rtmgrHttp.AllocNextSleep(50, false)
2419 newSubsId := mainCtrl.get_registry_next_subid(t)
2422 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2423 restSubId := xappConn1.SendRESTSubsReq(t, params)
2424 xappConn1.ExpectRESTNotificationNok(t, restSubId, "failAll")
2425 waiter.WaitResult(t)
2427 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2428 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
2431 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2433 // Wait that subs is cleaned
2434 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2435 waitSubsCleanup(t, e2SubsId, 10)
2436 mainCtrl.VerifyCounterValues(t)
2439 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
2440 CaseBegin("TestSubReqAndRouteUpdateNok")
2442 //Init counter check
2443 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2444 Counter{cRestSubReqFromXapp, 2},
2445 Counter{cRestSubRespToXapp, 2},
2446 Counter{cSubReqToE2, 1},
2447 Counter{cSubRespFromE2, 1},
2448 Counter{cRestSubNotifToXapp, 1},
2449 Counter{cRestSubFailNotifToXapp, 1},
2450 Counter{cRouteCreateUpdateFail, 1},
2451 Counter{cRestSubDelReqFromXapp, 1},
2452 Counter{cSubDelReqToE2, 1},
2453 Counter{cSubDelRespFromE2, 1},
2454 Counter{cRestSubDelRespToXapp, 1},
2457 var params *teststube2ap.RESTSubsReqParams = nil
2460 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2462 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2464 // xapp2 ROUTE creation shall fail with 400 from rtmgr -> submgr
2465 waiter := rtmgrHttp.AllocNextEvent(false)
2466 newSubsId := mainCtrl.get_registry_next_subid(t)
2467 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
2468 params.SetMeid("RAN_NAME_1")
2469 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2470 xapp.Logger.Info("Send REST subscriber request for second subscriber : %v", restSubId2)
2471 xappConn2.ExpectRESTNotificationNok(t, restSubId2, "allFail")
2472 waiter.WaitResult(t)
2473 // e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) - TOD: missing delete
2474 xappConn2.WaitRESTNotification(t, restSubId2)
2476 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2478 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2480 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2481 //Wait that subs is cleaned
2482 waitSubsCleanup(t, e2SubsId, 10)
2484 mainCtrl.VerifyCounterValues(t)
2487 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
2488 CaseBegin("TestRESTSubDelReqAndRouteDeleteNok")
2490 // Init counter check
2491 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2492 Counter{cRestSubReqFromXapp, 1},
2493 Counter{cRestSubRespToXapp, 1},
2494 Counter{cSubReqToE2, 1},
2495 Counter{cSubRespFromE2, 1},
2496 Counter{cRestSubNotifToXapp, 1},
2497 Counter{cRestSubDelReqFromXapp, 1},
2498 Counter{cRouteDeleteFail, 1},
2499 Counter{cSubDelReqToE2, 1},
2500 Counter{cSubDelRespFromE2, 1},
2501 Counter{cRestSubDelRespToXapp, 1},
2504 var params *teststube2ap.RESTSubsReqParams = nil
2507 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2509 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2511 waiter := rtmgrHttp.AllocNextEvent(false)
2512 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2513 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2514 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2515 waiter.WaitResult(t)
2517 waitSubsCleanup(t, e2SubsId, 10)
2519 mainCtrl.VerifyCounterValues(t)
2522 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
2523 CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok")
2525 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2526 Counter{cRestSubReqFromXapp, 2},
2527 Counter{cRestSubRespToXapp, 2},
2528 Counter{cSubReqToE2, 1},
2529 Counter{cSubRespFromE2, 1},
2530 Counter{cRestSubNotifToXapp, 2},
2531 Counter{cRestSubDelReqFromXapp, 2},
2532 Counter{cRouteDeleteUpdateFail, 1},
2533 Counter{cSubDelReqToE2, 1},
2534 Counter{cSubDelRespFromE2, 1},
2535 Counter{cRestSubDelRespToXapp, 2},
2538 var params *teststube2ap.RESTSubsReqParams = nil
2541 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2543 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2544 restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1")
2546 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
2548 //Del1, this shall fail on rtmgr side
2549 waiter := rtmgrHttp.AllocNextEvent(false)
2550 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2551 waiter.WaitResult(t)
2553 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"})
2556 deleteXapp2Subscription(t, &restSubId2)
2558 waitSubsCleanup(t, e2SubsId2, 10)
2560 mainCtrl.VerifyCounterValues(t)
2563 //-----------------------------------------------------------------------------
2564 // TestRESTSubReqRetransmission
2567 // +-------+ +---------+ +---------+
2568 // | xapp | | submgr | | e2term |
2569 // +-------+ +---------+ +---------+
2571 // | RESTSubReq1 | |
2572 // |---------------->| |
2574 // | RESTSubResp | |
2575 // |<----------------| |
2577 // | |------------->|
2579 // | RESTSubReq2 | |
2581 // |---------------->| |
2582 // | RESTSubResp(201)| |
2583 // |<----------------| |
2586 // | |<-------------|
2588 // |<----------------| |
2590 // | [SUBS DELETE] |
2593 //-----------------------------------------------------------------------------
2595 func TestRESTSubReqRetransmission(t *testing.T) {
2596 CaseBegin("TestRESTSubReqRetransmission")
2598 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2599 Counter{cRestSubReqFromXapp, 2},
2600 Counter{cRestSubRespToXapp, 2},
2601 Counter{cSubReqToE2, 1},
2602 Counter{cSubRespFromE2, 1},
2603 Counter{cRestSubNotifToXapp, 1},
2604 Counter{cRestSubDelReqFromXapp, 1},
2605 Counter{cSubDelReqToE2, 1},
2606 Counter{cSubDelRespFromE2, 1},
2607 Counter{cRestSubDelRespToXapp, 1},
2609 // Retry/duplicate will get the same way as the first request.
2610 // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
2611 // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
2614 const subReqCount int = 1
2616 // In order to force both XAPP's to create their own subscriptions, force rtmgr to block a while so that 2nd create
2617 // gets into execution before the rtmgrg responds for the first one.
2618 waiter := rtmgrHttp.AllocNextSleep(10, true)
2619 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2620 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
2621 xappConn2.SendRESTSubsReq(t, params)
2623 waiter.WaitResult(t)
2625 xappConn1.WaitListedRestNotifications(t, []string{restSubId1})
2627 // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
2628 // the order is not significant he6re.
2629 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2630 e2termConn1.SendSubsResp(t, crereq, cremsg)
2632 e2SubsIdA := <-xappConn1.ListedRESTNotifications
2633 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
2636 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
2637 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2638 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2640 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId}, 10)
2642 mainCtrl.VerifyCounterValues(t)
2645 //-----------------------------------------------------------------------------
2647 // +-------+ +---------+ +---------+ +---------+
2648 // | xapp | | submgr | | e2term | | rtmgr |
2649 // +-------+ +---------+ +---------+ +---------+
2651 // | RESTSubReq | | |
2652 // |---------------->| | |
2653 // | RESTSubResp | | |
2654 // |<----------------| | |
2655 // | | RouteCreate | |
2656 // | |--------------------------->|
2657 // | | RouteResponse| |
2658 // | |<---------------------------| // The order of these events may vary
2660 // | |------------->| | // The order of these events may vary
2662 // | |<-------------| |
2663 // | RESTNotif1 | | |
2664 // |<----------------| | |
2665 // | RESTSubReq | | |
2666 // | [RETRANS1] | | |
2667 // |---------------->| | |
2668 // | RESTNotif1 | | |
2669 // |<----------------| | |
2670 // | RESTSubReq | | |
2671 // | [RETRANS2] | | |
2672 // |---------------->| | |
2673 // | RESTNotif1 | | |
2674 // |<----------------| | |
2675 // | RESTSubDelReq | | |
2676 // |---------------->| | |
2677 // | | SubDelReq | |
2678 // | |------------->| |
2679 // | RESTSubDelResp| | |
2680 // |<----------------| | |
2681 // | | SubDelResp | |
2682 // | |<-------------| |
2685 //-----------------------------------------------------------------------------
2687 func TestRESTSubReqRetransmissionV2(t *testing.T) {
2688 CaseBegin("TestRESTSubReqRetransmissionV2")
2690 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2691 Counter{cRestSubReqFromXapp, 3},
2692 Counter{cRestSubRespToXapp, 3},
2693 Counter{cSubReqToE2, 1},
2694 Counter{cSubRespFromE2, 1},
2695 Counter{cRestSubNotifToXapp, 3},
2696 Counter{cRestSubDelReqFromXapp, 1},
2697 Counter{cSubDelReqToE2, 1},
2698 Counter{cSubDelRespFromE2, 1},
2699 Counter{cRestSubDelRespToXapp, 1},
2702 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2704 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2706 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2709 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
2711 assert.Equal(t, restSubId_resend, restSubId)
2713 <-time.After(100 * time.Millisecond)
2716 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
2718 assert.Equal(t, restSubId_resend2, restSubId)
2720 <-time.After(100 * time.Millisecond)
2722 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2724 waitSubsCleanup(t, e2SubsId, 10)
2726 //Wait that subs is cleaned
2727 mainCtrl.VerifyCounterValues(t)
2730 //-----------------------------------------------------------------------------
2732 // +-------+ +---------+ +---------+ +---------+
2733 // | xapp | | submgr | | e2term | | rtmgr |
2734 // +-------+ +---------+ +---------+ +---------+
2736 // | RESTSubReq | | |
2737 // |---------------->| | |
2738 // | RESTSubResp | | |
2739 // |<----------------| | |
2740 // | | RouteCreate | |
2741 // | |--------------------------->|
2742 // | | RouteResponse| |
2743 // | |<---------------------------| // The order of these events may vary
2745 // | |------------->| | // The order of these events may vary
2747 // | |<-------------| |
2748 // | RESTNotif1 | | |
2749 // |<----------------| | |
2750 // | RESTSubReq | | |
2751 // | [RETRANS, with RESTsubsId] | |
2752 // |---------------->| | |
2753 // | RESTNotif1 | | |
2754 // |<----------------| | |
2755 // | RESTSubReq | | |
2756 // | [RETRANS, without RESTsubsId] | |
2757 // |---------------->| | |
2758 // | RESTNotif1 | | |
2759 // |<----------------| | |
2760 // | RESTSubDelReq | | |
2761 // |---------------->| | |
2762 // | | SubDelReq | |
2763 // | |------------->| |
2764 // | RESTSubDelResp| | |
2765 // |<----------------| | |
2766 // | | SubDelResp | |
2767 // | |<-------------| |
2770 //-----------------------------------------------------------------------------
2771 func TestRESTSubReqRetransmissionV3(t *testing.T) {
2772 CaseBegin("TestRESTSubReqRetransmissionV3")
2774 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2775 Counter{cRestSubReqFromXapp, 3},
2776 Counter{cRestSubRespToXapp, 3},
2777 Counter{cSubReqToE2, 1},
2778 Counter{cSubRespFromE2, 1},
2779 Counter{cRestSubNotifToXapp, 3},
2780 Counter{cRestSubDelReqFromXapp, 1},
2781 Counter{cSubDelReqToE2, 1},
2782 Counter{cSubDelRespFromE2, 1},
2783 Counter{cRestSubDelRespToXapp, 1},
2786 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2788 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2790 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2792 <-time.After(100 * time.Millisecond)
2794 //1.st resend with subscription ID
2795 params.SetSubscriptionID(&restSubId)
2796 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
2798 assert.Equal(t, restSubId_resend, restSubId)
2800 <-time.After(100 * time.Millisecond)
2802 //2.nd resend without subscription ID (faking app restart)
2803 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
2804 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
2806 assert.Equal(t, restSubId_resend2, restSubId)
2808 <-time.After(100 * time.Millisecond)
2810 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2812 waitSubsCleanup(t, e2SubsId, 10)
2814 //Wait that subs is cleaned
2815 mainCtrl.VerifyCounterValues(t)
2818 //-----------------------------------------------------------------------------
2820 // +-------+ +---------+ +---------+ +---------+
2821 // | xapp | | submgr | | e2term | | rtmgr |
2822 // +-------+ +---------+ +---------+ +---------+
2824 // | RESTSubReq | | |
2825 // |---------------->| | |
2826 // | RESTSubResp | | |
2827 // |<----------------| | |
2828 // | | RouteCreate | |
2829 // | |--------------------------->|
2830 // | | RouteResponse| |
2831 // | |<---------------------------|
2833 // | |------------->| |
2835 // | |<-------------| |
2836 // | RESTNotif1 | | |
2837 // |<----------------| | |
2838 // | RESTSubReq | | |
2839 // | [with RestSUbsId + one additional e2 subDetail]
2840 // |---------------->| | |
2841 // | RESTNotif1 | | |
2842 // | [for initial e2 subDetail] | |
2843 // |<----------------| | |
2844 // | | RouteCreate | |
2845 // | |--------------------------->|
2846 // | | RouteResponse| |
2847 // | |<---------------------------|
2849 // | |------------->| |
2851 // | |<-------------| |
2852 // | RESTNotif1 | | |
2853 // |<----------------| | |
2854 // | RESTSubReq | | |
2855 // | [with RESTsubsId initial request] |
2856 // |---------------->| | |
2857 // | RESTNotif1 | | |
2858 // |<----------------| | |
2859 // | RESTSubDelReq | | |
2860 // |---------------->| | |
2861 // | RESTSubDelResp| | |
2862 // |<----------------| | |
2863 // | | SubDelReq | |
2864 // | |------------->| |
2865 // | | SubDelResp | |
2866 // | |<-------------| |
2867 // | | SubDelReq | |
2868 // | |------------->| |
2869 // | | SubDelResp | |
2870 // | |<-------------| |
2873 //-----------------------------------------------------------------------------
2875 func TestRESTSubReqRetransmissionV4(t *testing.T) {
2876 CaseBegin("TestRESTSubReqRetransmissionV4")
2878 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2879 Counter{cRestSubReqFromXapp, 3},
2880 Counter{cRestSubRespToXapp, 3},
2881 Counter{cSubReqToE2, 2},
2882 Counter{cSubRespFromE2, 2},
2883 Counter{cRestSubNotifToXapp, 4},
2884 Counter{cRestSubDelReqFromXapp, 1},
2885 Counter{cSubDelReqToE2, 2},
2886 Counter{cSubDelRespFromE2, 2},
2887 Counter{cRestSubDelRespToXapp, 1},
2890 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2892 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2894 <-time.After(100 * time.Millisecond)
2896 // Send modified requst, this time with e2 subscriptions.
2897 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
2898 params2.SetSubscriptionID(&restSubId)
2900 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
2901 xappConn1.ExpectAnyNotification(t)
2902 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
2903 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
2904 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
2905 assert.Equal(t, e2SubsId, e2SubsId1)
2907 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
2909 xappConn1.DecrementRequestCount()
2910 xappConn1.ExpectRESTNotification(t, restSubId_resend)
2911 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
2912 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
2913 assert.NotEqual(t, e2SubsId2, 0)
2915 <-time.After(100 * time.Millisecond)
2917 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
2918 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
2919 params.SetSubscriptionID(&restSubId)
2920 xappConn1.ExpectAnyNotification(t)
2921 // Resend the original request again with only one e2 subscription (detail), this time with restsubsid
2922 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
2923 assert.Equal(t, restSubId_resend, restSubId_resend2)
2925 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
2926 assert.Equal(t, e2SubsId, e2SubsId1)
2928 // Delete both e2 subscriptions
2929 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2930 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
2931 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
2933 waitSubsCleanup(t, e2SubsId, 10)
2935 //Wait that subs is cleaned
2936 mainCtrl.VerifyCounterValues(t)
2939 //-----------------------------------------------------------------------------
2941 // +-------+ +---------+ +---------+ +---------+
2942 // | xapp | | submgr | | e2term | | rtmgr |
2943 // +-------+ +---------+ +---------+ +---------+
2945 // | RESTSubReq | | |
2946 // |---------------->| | |
2947 // | RESTSubResp | | |
2948 // |<----------------| | |
2949 // | | RouteCreate | |
2950 // | |--------------------------->|
2951 // | | RouteResponse| |
2952 // | |<---------------------------|
2954 // | |------------->| |
2956 // | |<-------------| |
2957 // | RESTNotif1 | | |
2958 // |<----------------| | |
2959 // | RESTSubReq | | |
2960 // | [with RestSUbsId + one additional e2 subDetail]
2961 // |---------------->| | |
2962 // | RESTNotif1 | | |
2963 // | [for initial e2 subDetail] | |
2964 // |<----------------| | |
2965 // | | RouteCreate | |
2966 // | |--------------------------->|
2967 // | | RouteResponse| |
2968 // | |<---------------------------|
2970 // | |------------->| |
2972 // | |<-------------| |
2973 // | RESTNotif1 | | |
2974 // |<----------------| | |
2975 // | RESTSubReq | | |
2976 // | [without RESTsubsId initial request] |
2977 // |---------------->| | |
2978 // | RESTNotif1 | | |
2979 // |<----------------| | |
2980 // | RESTSubDelReq | | |
2981 // |---------------->| | |
2982 // | RESTSubDelResp| | |
2983 // |<----------------| | |
2984 // | | SubDelReq | |
2985 // | |------------->| |
2986 // | | SubDelResp | |
2987 // | |<-------------| |
2988 // | | SubDelReq | |
2989 // | |------------->| |
2990 // | | SubDelResp | |
2991 // | |<-------------| |
2994 //-----------------------------------------------------------------------------
2996 func TestRESTSubReqRetransmissionV5(t *testing.T) {
2997 CaseBegin("TestRESTSubReqRetransmissionV5")
2999 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3000 Counter{cRestSubReqFromXapp, 3},
3001 Counter{cRestSubRespToXapp, 3},
3002 Counter{cSubReqToE2, 2},
3003 Counter{cSubRespFromE2, 2},
3004 Counter{cRestSubNotifToXapp, 4},
3005 Counter{cRestSubDelReqFromXapp, 1},
3006 Counter{cSubDelReqToE2, 2},
3007 Counter{cSubDelRespFromE2, 2},
3008 Counter{cRestSubDelRespToXapp, 1},
3011 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3013 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3015 <-time.After(100 * time.Millisecond)
3017 // Send modified requst, this time with e2 subscriptions.
3018 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3019 params2.SetSubscriptionID(&restSubId)
3021 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3022 xappConn1.ExpectAnyNotification(t)
3023 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3024 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3026 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3027 assert.Equal(t, e2SubsId, e2SubsId1)
3028 // The first E2 subscription returns immediately, manually decrement expected request count for the remaining request handling
3029 xappConn1.DecrementRequestCount()
3031 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3033 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3034 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3035 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3036 assert.NotEqual(t, e2SubsId2, 0)
3038 <-time.After(100 * time.Millisecond)
3040 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3041 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3042 xappConn1.ExpectAnyNotification(t)
3043 // Resend the original request again with only one e2 subscription (detail), WITHOUT restsubsid
3044 // md5sum shall find the original request
3045 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3046 assert.Equal(t, restSubId_resend, restSubId_resend2)
3048 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3049 assert.Equal(t, e2SubsId, e2SubsId1)
3051 // Delete both e2 subscriptions
3052 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3053 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3054 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3056 waitSubsCleanup(t, e2SubsId, 10)
3058 //Wait that subs is cleaned
3059 mainCtrl.VerifyCounterValues(t)
3062 //-----------------------------------------------------------------------------
3064 // +-------+ +---------+ +---------+ +---------+
3065 // | xapp | | submgr | | e2term | | rtmgr |
3066 // +-------+ +---------+ +---------+ +---------+
3068 // | RESTSubReq | | |
3069 // |---------------->| | |
3070 // | RESTSubResp | | |
3071 // |<----------------| | |
3072 // | | RouteCreate | |
3073 // | |--------------------------->|
3074 // | | RouteResponse| |
3075 // | |<---------------------------|
3077 // | |------------->| |
3079 // | |<-------------| |
3080 // | RESTNotif1 | | |
3081 // |<----------------| | |
3082 // | RESTSubReq | | |
3083 // | [with RestSUbsId + one additional e2 subDetail]
3084 // |---------------->| | |
3085 // | RESTNotif1 | | |
3086 // | [for initial e2 subDetail] | |
3087 // |<----------------| | |
3088 // | | RouteCreate | |
3089 // | |--------------------------->|
3090 // | | RouteResponse| |
3091 // | |<---------------------------|
3093 // | |------------->| |
3095 // | |<-------------| |
3096 // | RESTNotif1 | | |
3097 // |<----------------| | |
3098 // | RESTSubDelReq | | |
3099 // |---------------->| | |
3100 // | RESTSubDelResp| | |
3101 // |<----------------| | |
3102 // | | SubDelReq | |
3103 // | |------------->| |
3104 // | | SubDelResp | |
3105 // | |<-------------| |
3106 // | | SubDelReq | |
3107 // | |------------->| |
3108 // | | SubDelResp | |
3109 // | |<-------------| |
3110 // | RESTSubReq | | |
3111 // | [with RESTsubsId initial request] |
3112 // |---------------->| | |
3113 // | RESTSubResp | | |
3114 // |<----------------| | |
3115 // | | RouteCreate | |
3116 // | |--------------------------->|
3117 // | | RouteResponse| |
3118 // | |<---------------------------|
3120 // | |------------->| |
3122 // | |<-------------| |
3123 // | RESTNotif1 | | |
3124 // |<----------------| | |
3127 //-----------------------------------------------------------------------------
3128 func TestRESTSubReqRetransmissionV6(t *testing.T) {
3129 CaseBegin("TestRESTSubReqRetransmissionV6")
3131 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3132 Counter{cRestSubReqFromXapp, 3},
3133 Counter{cRestSubRespToXapp, 3},
3134 Counter{cSubReqToE2, 3},
3135 Counter{cSubRespFromE2, 3},
3136 Counter{cRestSubNotifToXapp, 4},
3137 Counter{cRestSubDelReqFromXapp, 2},
3138 Counter{cSubDelReqToE2, 3},
3139 Counter{cSubDelRespFromE2, 3},
3140 Counter{cRestSubDelRespToXapp, 2},
3143 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3145 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3147 <-time.After(100 * time.Millisecond)
3149 // Send modified requst, this time with e2 subscriptions.
3150 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3151 params2.SetSubscriptionID(&restSubId)
3153 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3154 xappConn1.ExpectAnyNotification(t)
3155 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3156 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3158 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3159 assert.Equal(t, e2SubsId, e2SubsId1)
3161 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3163 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3164 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3165 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3166 assert.NotEqual(t, e2SubsId2, 0)
3168 <-time.After(100 * time.Millisecond)
3170 // Delete both e2 subscriptions
3171 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3172 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3173 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3175 waitSubsCleanup(t, e2SubsId, 10)
3177 // Resend the original request, we shall find it's previous md5sum/restsubs
3178 // but the restsubscription has been already removed. This shall trigger a
3180 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
3182 <-time.After(100 * time.Millisecond)
3184 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3186 waitSubsCleanup(t, e2SubsId, 10)
3188 //Wait that subs is cleaned
3189 mainCtrl.VerifyCounterValues(t)
3192 func TestRESTSubDelReqRetransmission(t *testing.T) {
3193 CaseBegin("TestRESTSubDelReqRetransmission")
3195 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3196 Counter{cRestSubReqFromXapp, 1},
3197 Counter{cRestSubRespToXapp, 1},
3198 Counter{cSubReqToE2, 1},
3199 Counter{cSubRespFromE2, 1},
3200 Counter{cRestSubNotifToXapp, 1},
3201 Counter{cRestSubDelReqFromXapp, 2},
3202 Counter{cSubDelReqToE2, 1},
3203 Counter{cSubDelRespFromE2, 1},
3204 Counter{cRestSubDelRespToXapp, 1},
3207 var params *teststube2ap.RESTSubsReqParams = nil
3210 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3212 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3215 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3216 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3218 seqBef := mainCtrl.get_msgcounter(t)
3219 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3220 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
3222 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3224 waitSubsCleanup(t, e2SubsId, 10)
3226 mainCtrl.VerifyCounterValues(t)
3229 //-----------------------------------------------------------------------------
3230 // TestRESTSubReqDelReq
3233 // +-------+ +---------+ +---------+
3234 // | xapp | | submgr | | e2term |
3235 // +-------+ +---------+ +---------+
3238 // |---------------->| |
3240 // | RESTSubResp | |
3241 // |<----------------| |
3243 // | |------------->|
3244 // | RESTSubDelReq | |
3245 // |---------------->| |
3246 // | RESTSubDelResp | |
3248 // |<----------------| |
3250 // | |<-------------|
3252 // |<----------------| |
3254 // | [SUBS DELETE] |
3257 //-----------------------------------------------------------------------------
3258 func TestRESTSubReqDelReq(t *testing.T) {
3259 CaseBegin("TestRESTSubReqDelReq")
3261 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3262 Counter{cRestSubReqFromXapp, 1},
3263 Counter{cRestSubRespToXapp, 1},
3264 Counter{cSubReqToE2, 1},
3265 Counter{cSubRespFromE2, 1},
3266 Counter{cRestSubNotifToXapp, 1},
3267 Counter{cRestSubDelReqFromXapp, 2},
3268 Counter{cSubDelReqToE2, 1},
3269 Counter{cSubDelRespFromE2, 1},
3270 Counter{cRestSubDelRespToXapp, 1},
3273 const subReqCount int = 1
3276 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3277 restSubId := xappConn1.SendRESTSubsReq(t, params)
3279 // Del. This will fail as processing of the subscription
3280 // is still ongoing in submgr. Deletion is not allowed before
3281 // subscription creation has been completed.
3282 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3283 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3284 xappConn1.ExpectRESTNotification(t, restSubId)
3285 e2termConn1.SendSubsResp(t, crereq, cremsg)
3286 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3289 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3291 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3292 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3294 // Wait that subs is cleaned
3295 waitSubsCleanup(t, e2SubsId, 10)
3296 mainCtrl.VerifyCounterValues(t)
3300 func TestRESTSubDelReqCollision(t *testing.T) {
3301 CaseBegin("TestRESTSubDelReqCollision - not relevant for REST API")
3304 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
3305 CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel")
3307 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3308 Counter{cRestSubReqFromXapp, 2},
3309 Counter{cRestSubRespToXapp, 2},
3310 Counter{cSubReqToE2, 2},
3311 Counter{cSubRespFromE2, 2},
3312 Counter{cRestSubNotifToXapp, 2},
3313 Counter{cRestSubDelReqFromXapp, 2},
3314 Counter{cSubDelReqToE2, 2},
3315 Counter{cSubDelRespFromE2, 2},
3316 Counter{cRestSubDelRespToXapp, 2},
3320 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3321 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3322 xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3325 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3326 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3327 xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3329 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3330 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3332 //XappConn1 receives both of the responses
3333 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3336 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3338 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3340 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3341 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3342 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3343 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3346 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3348 deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
3350 //Wait that subs is cleaned
3351 mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
3352 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
3354 mainCtrl.VerifyCounterValues(t)
3358 func TestRESTSameSubsDiffRan(t *testing.T) {
3359 CaseBegin("TestRESTSameSubsDiffRan")
3361 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3362 Counter{cRestSubReqFromXapp, 2},
3363 Counter{cRestSubRespToXapp, 2},
3364 Counter{cSubReqToE2, 2},
3365 Counter{cSubRespFromE2, 2},
3366 Counter{cRestSubNotifToXapp, 2},
3367 Counter{cRestSubDelReqFromXapp, 2},
3368 Counter{cSubDelReqToE2, 2},
3369 Counter{cSubDelRespFromE2, 2},
3370 Counter{cRestSubDelRespToXapp, 2},
3373 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3374 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3375 xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3377 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3378 params.SetMeid("RAN_NAME_2")
3379 restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
3380 xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3383 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3385 deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
3387 //Wait that subs is cleaned
3388 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3389 waitSubsCleanup(t, e2SubsId2, 10)
3391 mainCtrl.VerifyCounterValues(t)
3395 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
3396 CaseBegin("TestRESTSubReqRetryInSubmgr start")
3398 // Init counter check
3399 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3400 Counter{cRestSubReqFromXapp, 1},
3401 Counter{cRestSubRespToXapp, 1},
3402 Counter{cSubReqToE2, 1},
3403 Counter{cSubReReqToE2, 1},
3404 Counter{cSubRespFromE2, 1},
3405 Counter{cRestSubNotifToXapp, 1},
3406 Counter{cRestSubDelReqFromXapp, 1},
3407 Counter{cSubDelReqToE2, 1},
3408 Counter{cSubDelRespFromE2, 1},
3409 Counter{cRestSubDelRespToXapp, 1},
3412 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3413 restSubId := xappConn1.SendRESTSubsReq(t, params)
3415 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
3417 // Catch the first message and ignore it
3418 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3419 xapp.Logger.Info("Ignore REST subscriber request for subscriber : %v", restSubId)
3421 // The second request is being handled normally
3422 crereq, cremsg = e2termConn1.RecvSubsReq(t)
3423 xappConn1.ExpectRESTNotification(t, restSubId)
3424 e2termConn1.SendSubsResp(t, crereq, cremsg)
3425 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3427 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3429 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3431 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
3432 //Wait that subs is cleaned
3433 waitSubsCleanup(t, e2SubsId, 10)
3435 mainCtrl.VerifyCounterValues(t)
3439 //-----------------------------------------------------------------------------
3440 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3443 // +-------+ +---------+ +---------+
3444 // | xapp | | submgr | | e2term |
3445 // +-------+ +---------+ +---------+
3448 // |---------------->| |
3450 // | RESTSubResp | |
3451 // |<----------------| |
3453 // | |------------->|
3457 // | |------------->|
3460 // | |------------->|
3464 // | |------------->|
3468 // | |<-------------|
3471 // |<----------------| |
3473 // | [SUBS DELETE] |
3476 //-----------------------------------------------------------------------------
3478 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
3479 CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
3481 // Init counter check
3482 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3483 Counter{cRestSubReqFromXapp, 1},
3484 Counter{cRestSubRespToXapp, 1},
3485 Counter{cSubReqToE2, 1},
3486 Counter{cSubReReqToE2, 1},
3487 Counter{cSubReqTimerExpiry, 2},
3488 Counter{cSubDelReqToE2, 1},
3489 Counter{cSubDelRespFromE2, 1},
3492 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3493 restSubId := xappConn1.SendRESTSubsReq(t, params)
3494 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
3496 e2termConn1.RecvSubsReq(t)
3497 xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3499 e2termConn1.RecvSubsReq(t)
3500 xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3502 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3503 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3504 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3505 xappConn1.WaitRESTNotification(t, restSubId)
3507 // Wait that subs is cleaned
3508 waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
3510 mainCtrl.VerifyCounterValues(t)
3513 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
3514 CaseBegin("TestREST2eTermNotRespondingToSubReq start")
3516 // Init counter check
3517 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3518 Counter{cRestSubReqFromXapp, 1},
3519 Counter{cRestSubRespToXapp, 1},
3520 Counter{cSubReqToE2, 1},
3521 Counter{cSubReReqToE2, 1},
3522 Counter{cSubReqTimerExpiry, 2},
3523 Counter{cSubDelReqToE2, 1},
3524 Counter{cSubDelReqTimerExpiry, 2},
3527 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3528 restSubId := xappConn1.SendRESTSubsReq(t, params)
3529 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
3531 e2termConn1.RecvSubsReq(t)
3532 xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3534 e2termConn1.RecvSubsReq(t)
3535 xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3537 e2termConn1.RecvSubsDelReq(t)
3538 xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3540 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3541 e2termConn1.RecvSubsDelReq(t)
3542 xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3544 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3546 waitSubsCleanup(t, e2SubsId, 10)
3548 mainCtrl.VerifyCounterValues(t)
3552 //-----------------------------------------------------------------------------
3553 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3556 // +-------+ +---------+ +---------+
3557 // | xapp | | submgr | | e2term |
3558 // +-------+ +---------+ +---------+
3561 // |---------------->| |
3563 // | RESTSubResp | |
3564 // |<----------------| |
3566 // | |------------->|
3570 // | |------------->|
3573 // | |------------->|
3577 // | |------------->|
3581 // | |<-------------|
3584 // |<----------------| |
3586 // | [SUBS DELETE] |
3589 //-----------------------------------------------------------------------------
3590 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
3591 CaseBegin("TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr start")
3593 // Init counter check
3594 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3595 Counter{cRestSubReqFromXapp, 1},
3596 Counter{cRestSubRespToXapp, 1},
3597 Counter{cSubReqToE2, 1},
3598 Counter{cSubReReqToE2, 1},
3599 Counter{cSubReqTimerExpiry, 2},
3600 Counter{cSubDelReqToE2, 1},
3601 Counter{cSubDelReReqToE2, 1},
3602 Counter{cSubDelReqTimerExpiry, 2},
3605 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3606 restSubId := xappConn1.SendRESTSubsReq(t, params)
3607 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
3609 e2termConn1.RecvSubsReq(t)
3610 xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3612 e2termConn1.RecvSubsReq(t)
3613 xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3615 e2termConn1.RecvSubsDelReq(t)
3616 xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3618 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3619 e2termConn1.RecvSubsDelReq(t)
3620 xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3622 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3624 waitSubsCleanup(t, e2SubsId, 10)
3626 mainCtrl.VerifyCounterValues(t)
3629 //-----------------------------------------------------------------------------
3630 // TestRESTSubReqSubFailRespInSubmgr
3633 // +-------+ +---------+ +---------+
3634 // | xapp | | submgr | | e2term |
3635 // +-------+ +---------+ +---------+
3638 // |---------------->| |
3640 // | RESTSubResp | |
3641 // |<----------------| |
3643 // | |------------->|
3646 // | |<-------------|
3649 // | |------------->|
3652 // | |<-------------|
3656 // |<----------------| |
3658 // | [SUBS DELETE] |
3661 //-----------------------------------------------------------------------------
3662 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
3663 CaseBegin("TestRESTSubReqSubFailRespInSubmgr")
3665 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3666 Counter{cRestSubReqFromXapp, 1},
3667 Counter{cRestSubRespToXapp, 1},
3668 Counter{cSubReqToE2, 1},
3669 Counter{cSubFailFromE2, 1},
3670 Counter{cRestSubFailNotifToXapp, 1},
3671 Counter{cRestSubDelReqFromXapp, 1},
3674 const subReqCount int = 1
3676 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3677 restSubId := xappConn1.SendRESTSubsReq(t, params)
3679 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3680 fparams1 := &teststube2ap.E2StubSubsFailParams{}
3681 fparams1.Set(crereq1)
3682 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3684 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3685 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3686 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3687 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3688 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
3690 // REST subscription sill there to be deleted
3691 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3693 // Wait that subs is cleaned
3694 waitSubsCleanup(t, e2SubsId, 10)
3696 mainCtrl.VerifyCounterValues(t)
3700 //-----------------------------------------------------------------------------
3701 // TestRESTSubDelReqRetryInSubmgr
3704 // +-------+ +---------+ +---------+
3705 // | xapp | | submgr | | e2term |
3706 // +-------+ +---------+ +---------+
3708 // | [SUBS CREATE] |
3711 // | RESTSubDelReq | |
3712 // |---------------->| |
3714 // | RESTSubDelResp | |
3715 // |<----------------| |
3717 // | |------------->|
3720 // | |------------->|
3723 // | |<-------------|
3726 //-----------------------------------------------------------------------------
3727 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
3728 CaseBegin("TestRESTSubDelReqRetryInSubmgr")
3730 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3731 Counter{cRestSubReqFromXapp, 1},
3732 Counter{cRestSubRespToXapp, 1},
3733 Counter{cSubReqToE2, 1},
3734 Counter{cSubRespFromE2, 1},
3735 Counter{cRestSubNotifToXapp, 1},
3736 Counter{cRestSubDelReqFromXapp, 1},
3737 Counter{cSubDelReqToE2, 1},
3738 Counter{cSubDelReReqToE2, 1},
3739 Counter{cSubDelRespFromE2, 1},
3740 Counter{cRestSubDelRespToXapp, 1},
3743 var params *teststube2ap.RESTSubsReqParams = nil
3744 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3747 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3749 // E2t: Receive 1st SubsDelReq
3750 e2termConn1.RecvSubsDelReq(t)
3752 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
3753 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3754 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3756 //Wait that subs is cleaned
3757 waitSubsCleanup(t, e2SubsId, 10)
3759 mainCtrl.VerifyCounterValues(t)
3762 //-----------------------------------------------------------------------------
3763 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
3766 // +-------+ +---------+ +---------+
3767 // | xapp | | submgr | | e2term |
3768 // +-------+ +---------+ +---------+
3770 // | [SUBS CREATE] |
3773 // | RESTSubDelReq | |
3774 // |---------------->| |
3776 // | RESTSubDelResp | |
3777 // |<----------------| |
3779 // | |------------->|
3782 // | |------------->|
3786 //-----------------------------------------------------------------------------
3787 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
3788 CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr")
3790 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3791 Counter{cRestSubReqFromXapp, 1},
3792 Counter{cRestSubRespToXapp, 1},
3793 Counter{cSubReqToE2, 1},
3794 Counter{cSubRespFromE2, 1},
3795 Counter{cRestSubNotifToXapp, 1},
3796 Counter{cRestSubDelReqFromXapp, 1},
3797 Counter{cSubDelReqToE2, 1},
3798 Counter{cSubDelReReqToE2, 1},
3799 Counter{cSubDelRespFromE2, 1},
3800 Counter{cRestSubDelRespToXapp, 1},
3804 var params *teststube2ap.RESTSubsReqParams = nil
3805 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3808 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3810 // E2t: Receive 1st SubsDelReq
3811 e2termConn1.RecvSubsDelReq(t)
3813 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
3814 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3815 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3817 //Wait that subs is cleaned
3818 waitSubsCleanup(t, e2SubsId, 10)
3820 mainCtrl.VerifyCounterValues(t)
3823 //-----------------------------------------------------------------------------
3824 // TestRESTSubDelReqSubDelFailRespInSubmgr
3827 // +-------+ +---------+ +---------+
3828 // | xapp | | submgr | | e2term |
3829 // +-------+ +---------+ +---------+
3831 // | [SUBS CREATE] |
3834 // | RESTSubDelReq | |
3835 // |---------------->| |
3837 // | RESTSubDelResp | |
3838 // |<----------------| |
3840 // | |------------->|
3843 // | |<-------------|
3846 //-----------------------------------------------------------------------------
3847 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
3848 CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr")
3850 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3851 Counter{cRestSubReqFromXapp, 1},
3852 Counter{cRestSubRespToXapp, 1},
3853 Counter{cSubReqToE2, 1},
3854 Counter{cSubRespFromE2, 1},
3855 Counter{cRestSubNotifToXapp, 1},
3856 Counter{cRestSubDelReqFromXapp, 1},
3857 Counter{cSubDelReqToE2, 1},
3858 Counter{cSubDelFailFromE2, 1},
3859 Counter{cRestSubDelRespToXapp, 1},
3863 var params *teststube2ap.RESTSubsReqParams = nil
3864 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3867 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3869 // E2t: Send receive SubsDelReq and send SubsDelFail
3870 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3871 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
3873 //Wait that subs is cleaned
3874 waitSubsCleanup(t, e2SubsId, 10)
3876 mainCtrl.VerifyCounterValues(t)
3879 //-----------------------------------------------------------------------------
3880 // TestRESTSubReqAndSubDelOkSameAction
3883 // +-------+ +-------+ +---------+ +---------+
3884 // | xapp2 | | xapp1 | | submgr | | e2term |
3885 // +-------+ +-------+ +---------+ +---------+
3887 // | | RESTSubReq1 | |
3888 // | |---------------->| |
3890 // | | RESTSubResp1 | |
3891 // | |<----------------| |
3894 // | | |------------->|
3896 // | | |<-------------|
3897 // | | RESTNotif1 | |
3898 // | |<----------------| |
3900 // | RESTSubReq2 | |
3901 // |------------------------------>| |
3903 // | RESTSubResp2 | |
3904 // |<------------------------------| |
3906 // | | RESTNotif2 | |
3907 // |<------------------------------| |
3909 // | | RESTSubDelReq1 | |
3910 // | |---------------->| |
3912 // | | RESTSubDelResp1 | |
3913 // | |<----------------| |
3915 // | RESTSubDelReq2 | |
3916 // |------------------------------>| |
3918 // | RESTSubDelResp2 | |
3919 // |<------------------------------| |
3921 // | | | SubDelReq2 |
3922 // | | |------------->|
3924 // | | | SubDelResp2 |
3925 // | | |<-------------|
3928 //-----------------------------------------------------------------------------
3929 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
3930 CaseBegin("TestRESTSubReqAndSubDelOkSameAction")
3932 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3933 Counter{cRestSubReqFromXapp, 2},
3934 Counter{cRestSubRespToXapp, 2},
3935 Counter{cSubReqToE2, 1},
3936 Counter{cSubRespFromE2, 1},
3937 Counter{cRestSubNotifToXapp, 2},
3938 Counter{cMergedSubscriptions, 1},
3939 Counter{cUnmergedSubscriptions, 1},
3940 Counter{cRestSubDelReqFromXapp, 2},
3941 Counter{cSubDelReqToE2, 1},
3942 Counter{cSubDelRespFromE2, 1},
3943 Counter{cRestSubDelRespToXapp, 2},
3947 var params *teststube2ap.RESTSubsReqParams = nil
3950 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3951 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
3954 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3955 params.SetMeid("RAN_NAME_1")
3957 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
3958 xappConn2.ExpectAnyNotification(t)
3959 waiter := rtmgrHttp.AllocNextSleep(10, true)
3960 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3961 waiter.WaitResult(t)
3962 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
3963 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
3964 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
3966 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
3969 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3972 deleteXapp2Subscription(t, &restSubId2)
3974 //Wait that subs is cleaned
3975 waitSubsCleanup(t, e2SubsId2, 10)
3977 mainCtrl.VerifyCounterValues(t)
3980 //-----------------------------------------------------------------------------
3981 // TestSubReqAndSubDelOkSameActionParallel
3984 // +-------+ +-------+ +---------+ +---------+
3985 // | xapp2 | | xapp1 | | submgr | | e2term |
3986 // +-------+ +-------+ +---------+ +---------+
3991 // | |------------->| |
3994 // | | |------------->|
3996 // |--------------------------->| |
3998 // | | |<-------------|
4000 // | |<-------------| |
4002 // | | |------------->|
4005 // | | |<-------------|
4007 // |<---------------------------| |
4009 // | | SubDelReq 1 | |
4010 // | |------------->| |
4012 // | | SubDelResp 1 | |
4013 // | |<-------------| |
4015 // | SubDelReq 2 | |
4016 // |--------------------------->| |
4018 // | | | SubDelReq 2 |
4019 // | | |------------->|
4021 // | | | SubDelReq 2 |
4022 // | | |------------->|
4024 // | SubDelResp 2 | |
4025 // |<---------------------------| |
4027 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
4028 CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel")
4030 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4031 Counter{cRestSubReqFromXapp, 2},
4032 Counter{cRestSubRespToXapp, 2},
4033 Counter{cSubReqToE2, 2},
4034 Counter{cSubRespFromE2, 2},
4035 Counter{cRestSubNotifToXapp, 2},
4036 Counter{cRestSubDelReqFromXapp, 2},
4037 Counter{cSubDelReqToE2, 2},
4038 Counter{cSubDelRespFromE2, 2},
4039 Counter{cRestSubDelRespToXapp, 2},
4042 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4043 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4044 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4046 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4047 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4049 xappConn1.ExpectRESTNotification(t, restSubId1)
4050 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4051 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4053 xappConn2.ExpectRESTNotification(t, restSubId2)
4054 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
4055 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
4056 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4059 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4060 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4061 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4062 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4065 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4066 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
4067 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
4069 waitSubsCleanup(t, e2SubsId2, 10)
4071 mainCtrl.VerifyCounterValues(t)
4074 //-----------------------------------------------------------------------------
4075 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
4078 // +-------+ +-------+ +---------+ +---------+
4079 // | xapp2 | | xapp1 | | submgr | | e2term |
4080 // +-------+ +-------+ +---------+ +---------+
4084 // | | RESTSubReq1 | |
4085 // | |---------------->| |
4087 // | | RESTSubResp1 | |
4088 // | |<----------------| |
4090 // | | |------------->|
4091 // | RESTSubReq2 | |
4092 // |------------------------------>| |
4094 // | RESTSubDelResp2 | |
4095 // |<------------------------------| |
4097 // | | |------------->|
4100 // | | | SubDelReq |
4101 // | | |------------->|
4103 // | | | SubDelResp |
4104 // | | |<-------------|
4105 // | | RESTNotif1 | |
4106 // | | unsuccess | |
4107 // | |<----------------| |
4109 // | | unsuccess | |
4110 // |<------------------------------| |
4112 // | | RESTSubDelReq1 | |
4113 // | |---------------->| |
4115 // | | RESTSubDelResp1 | |
4116 // | |<----------------| |
4118 // | RESTSubDelReq2 | |
4119 // |------------------------------>| |
4121 // | RESTSubDelResp2 | |
4122 // |<------------------------------| |
4124 //-----------------------------------------------------------------------------
4125 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
4126 CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
4128 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4129 Counter{cRestSubReqFromXapp, 2},
4130 Counter{cRestSubRespToXapp, 2},
4131 Counter{cSubReqToE2, 1},
4132 Counter{cRestSubFailNotifToXapp, 2},
4133 Counter{cRestSubDelReqFromXapp, 2},
4134 Counter{cSubDelReqToE2, 1},
4135 Counter{cSubDelRespFromE2, 1},
4136 Counter{cRestSubDelRespToXapp, 2},
4139 const subReqCount int = 1
4142 params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4143 restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
4144 crereq1, _ := e2termConn1.RecvSubsReq(t)
4147 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4148 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4149 params2.SetMeid("RAN_NAME_1")
4150 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4151 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4153 //Req1 (retransmitted)
4154 e2termConn1.RecvSubsReq(t)
4156 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4158 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4159 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4161 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4162 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4163 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4164 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4167 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4170 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4172 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
4174 //Wait that subs is cleaned
4175 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4177 mainCtrl.VerifyCounterValues(t)
4180 //-----------------------------------------------------------------------------
4181 // TestRESTSubReqAndSubDelNokSameActionParallel
4184 // +-------+ +-------+ +---------+ +---------+
4185 // | xapp2 | | xapp1 | | submgr | | e2term |
4186 // +-------+ +-------+ +---------+ +---------+
4190 // | | RESTSubReq1 | |
4191 // | |---------------->| |
4193 // | | RESTSubResp1 | |
4194 // | |<----------------| |
4196 // | | |------------->|
4197 // | RESTSubReq2 | |
4198 // |------------------------------>| |
4200 // | RESTSubDelResp2 | |
4201 // |<------------------------------| |
4203 // | | |<-------------|
4205 // | | RESTNotif1 | |
4206 // | | unsuccess | |
4207 // | |<----------------| |
4209 // | | unsuccess | |
4210 // |<------------------------------| |
4211 // | | | SubDelReq |
4212 // | | |------------->|
4213 // | | | SubDelResp |
4214 // | | |<-------------|
4216 // | | RESTSubDelReq1 | |
4217 // | |---------------->| |
4219 // | | RESTSubDelResp1 | |
4220 // | |<----------------| |
4222 // | RESTSubDelReq2 | |
4223 // |------------------------------>| |
4225 // | RESTSubDelResp2 | |
4226 // |<------------------------------| |
4228 //-----------------------------------------------------------------------------
4229 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
4230 CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
4232 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4233 Counter{cRestSubReqFromXapp, 2},
4234 Counter{cRestSubRespToXapp, 2},
4235 Counter{cSubReqToE2, 1},
4236 Counter{cSubFailFromE2, 1},
4237 Counter{cRestSubFailNotifToXapp, 2},
4238 Counter{cRestSubDelReqFromXapp, 2},
4239 Counter{cSubDelReqToE2, 1},
4240 Counter{cSubDelRespFromE2, 1},
4241 Counter{cRestSubDelRespToXapp, 2},
4244 const subReqCount int = 1
4247 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4248 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4249 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4252 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4253 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4254 params2.SetMeid("RAN_NAME_1")
4255 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4256 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4258 // E2t: send SubsFail (first)
4259 fparams1 := &teststube2ap.E2StubSubsFailParams{}
4260 fparams1.Set(crereq1)
4261 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
4263 // E2t: internal delete
4264 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4265 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4266 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4268 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4269 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4270 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4271 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4274 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4277 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4279 //Wait that subs is cleaned
4280 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4281 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
4283 mainCtrl.VerifyCounterValues(t)
4286 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
4287 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4289 // Init counter check
4290 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4291 Counter{cRestSubReqFromXapp, 1},
4292 Counter{cRestSubRespToXapp, 1},
4293 Counter{cSubReqToE2, 1},
4294 Counter{cSubRespFromE2, 1},
4295 Counter{cRestSubNotifToXapp, 1},
4296 Counter{cRestSubDelReqFromXapp, 1},
4297 Counter{cSubDelReqToE2, 1},
4298 Counter{cSubDelRespFromE2, 1},
4299 Counter{cRestSubDelRespToXapp, 1},
4302 const subReqCount int = 1
4304 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4305 restSubId := xappConn1.SendRESTSubsReq(t, params)
4306 xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
4308 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4309 xappConn1.ExpectRESTNotification(t, restSubId)
4310 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4311 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4312 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
4314 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4315 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4316 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4318 // Wait that subs is cleaned
4319 waitSubsCleanup(t, e2SubsId, 10)
4320 mainCtrl.VerifyCounterValues(t)
4323 //-----------------------------------------------------------------------------
4324 // TestRESTSubReqPolicyChangeAndSubDelOk
4327 // +-------+ +---------+ +---------+
4328 // | xapp | | submgr | | e2term |
4329 // +-------+ +---------+ +---------+
4332 // |---------------->| |
4334 // | RESTSubResp | |
4335 // |<----------------| |
4337 // | |------------->|
4340 // | |<-------------|
4343 // |<----------------| |
4346 // |---------------->| |
4348 // | RESTSubResp | |
4349 // |<----------------| |
4351 // | |------------->|
4354 // | |<-------------|
4357 // |<----------------| |
4359 // | RESTSubDelReq | |
4360 // |---------------->| |
4363 // | |------------->|
4366 // | |<-------------|
4368 // | RESTSubDelResp | |
4369 // |<----------------| |
4371 //-----------------------------------------------------------------------------
4372 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
4373 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4375 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4376 Counter{cRestSubReqFromXapp, 2},
4377 Counter{cRestSubRespToXapp, 2},
4378 Counter{cSubReqToE2, 2},
4379 Counter{cSubRespFromE2, 2},
4380 Counter{cRestSubNotifToXapp, 2},
4381 Counter{cRestSubDelReqFromXapp, 1},
4382 Counter{cSubDelReqToE2, 1},
4383 Counter{cSubDelRespFromE2, 1},
4384 Counter{cRestSubDelRespToXapp, 1},
4387 const subReqCount int = 1
4390 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4391 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4394 // GetRESTSubsReqPolicyParams sets some coutners on tc side.
4396 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4397 params.SetSubscriptionID(&restSubId)
4398 params.SetTimeToWait("w200ms")
4399 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
4402 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4404 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4405 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4407 // Wait that subs is cleaned
4408 waitSubsCleanup(t, e2SubsId, 10)
4409 mainCtrl.VerifyCounterValues(t)
4412 //-----------------------------------------------------------------------------
4413 // TestRESTSubReqPolicyChangeNOk
4416 // +-------+ +---------+ +---------+
4417 // | xapp | | submgr | | e2term |
4418 // +-------+ +---------+ +---------+
4421 // |---------------->| |
4423 // | RESTSubResp | |
4424 // |<----------------| |
4426 // | |------------->|
4429 // | |<-------------|
4432 // |<----------------| |
4435 // |---------------->| |
4437 // | RESTSubUpdateFail |
4439 // | RESTSubDelReq | |
4440 // |---------------->| |
4443 // | |------------->|
4446 // | |<-------------|
4448 // | RESTSubDelResp | |
4449 // |<----------------| |
4451 //-----------------------------------------------------------------------------
4452 func TestRESTSubReqPolicyChangeNOk(t *testing.T) {
4453 CaseBegin("TestRESTSubReqPolicyChangeNOk")
4455 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4456 Counter{cRestSubReqFromXapp, 2},
4457 Counter{cRestSubRespToXapp, 1},
4458 Counter{cSubReqToE2, 1},
4459 Counter{cSubRespFromE2, 1},
4460 Counter{cRestSubNotifToXapp, 1},
4461 Counter{cRestSubFailToXapp, 1},
4462 Counter{cRestSubDelReqFromXapp, 1},
4463 Counter{cSubDelReqToE2, 1},
4464 Counter{cSubDelRespFromE2, 1},
4465 Counter{cRestSubDelRespToXapp, 1},
4468 const subReqCount int = 1
4471 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4472 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4476 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4478 restSubIdUpd := strings.ToUpper(restSubId)
4479 params.SetSubscriptionID(&restSubIdUpd)
4480 params.SetTimeToWait("w200ms")
4482 restSubId2 := xappConn1.SendRESTSubsReq(t, params)
4483 assert.Equal(t, restSubId2, "")
4486 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4488 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4489 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4491 // Wait that subs is cleaned
4492 waitSubsCleanup(t, e2SubsId, 10)
4493 mainCtrl.VerifyCounterValues(t)
4496 //-----------------------------------------------------------------------------
4497 // TestRESTSubReqAndSubDelOkTwoE2termParallel
4500 // +-------+ +---------+ +---------+ +---------+
4501 // | xapp | | submgr | | e2term1 | | e2term2 |
4502 // +-------+ +---------+ +---------+ +---------+
4506 // | RESTSubReq1 | | |
4507 // |---------------->| | |
4509 // | RESTSubResp1 | | |
4510 // |<----------------| | |
4512 // | |------------->| |
4514 // | RESTSubReq2 | | |
4515 // |---------------->| | |
4517 // | RESTSubResp2 | | |
4518 // |<----------------| | |
4520 // | |---------------------------->|
4523 // | |<-------------| |
4524 // | RESTNotif1 | | |
4525 // |<----------------| | |
4527 // | |<----------------------------|
4528 // | RESTNotif2 | | |
4529 // |<----------------| | |
4531 // | [SUBS 1 DELETE] | |
4533 // | [SUBS 2 DELETE] | |
4536 //-----------------------------------------------------------------------------
4537 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
4538 CaseBegin("TestRESTSubReqAndSubDelOkTwoE2termParallel")
4540 // Init counter check
4541 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4542 Counter{cRestSubReqFromXapp, 2},
4543 Counter{cRestSubRespToXapp, 2},
4544 Counter{cSubReqToE2, 2},
4545 Counter{cSubRespFromE2, 2},
4546 Counter{cRestSubNotifToXapp, 2},
4547 Counter{cRestSubDelReqFromXapp, 2},
4548 Counter{cSubDelReqToE2, 2},
4549 Counter{cSubDelRespFromE2, 2},
4550 Counter{cRestSubDelRespToXapp, 2},
4553 const subReqCount int = 1
4556 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4557 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4558 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4561 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4562 params.SetMeid("RAN_NAME_11")
4563 // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
4564 // would not work as notification would not be received
4565 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4566 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
4569 xappConn1.ExpectRESTNotification(t, restSubId1)
4570 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4571 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4572 xapp.Logger.Info("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
4575 xappConn2.ExpectRESTNotification(t, restSubId2)
4576 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
4577 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4578 xapp.Logger.Info("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
4581 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4582 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4583 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4585 // Wait that subs is cleaned
4586 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4589 xappConn1.SendRESTSubsDelReq(t, &restSubId2)
4590 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
4591 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
4593 // Wait that subs is cleaned
4594 waitSubsCleanup(t, e2SubsId2, 10)
4596 mainCtrl.VerifyCounterValues(t)
4599 //-----------------------------------------------------------------------------
4600 // TestRESTSubReqAsn1EncodeFail
4602 // In this case submgr send RICSubscriptionDeleteRequest after encode failure which should not happen!
4604 // +-------+ +---------+ +---------+
4605 // | xapp | | submgr | | e2term |
4606 // +-------+ +---------+ +---------+
4609 // |---------------->| |
4611 // | RESTSubResp | |
4612 // |<----------------| |
4613 // | RESTSubDelReq | |
4614 // |---------------->| |
4615 // | RESTSubDelResp | |
4617 // |<----------------| |
4620 //-----------------------------------------------------------------------------
4621 func TestRESTSubReqAsn1EncodeFail(t *testing.T) {
4622 CaseBegin("TestRESTSubReqAsn1EncodeFail")
4624 xapp.Logger.Info("Xapp-frame, v0.8.1 sufficient REST API validation")
4628 //-----------------------------------------------------------------------------
4629 // TestRESTSubReqInsertAndSubDelOk
4632 // +-------+ +---------+ +---------+
4633 // | xapp | | submgr | | e2term |
4634 // +-------+ +---------+ +---------+
4637 // |---------------->| |
4639 // | RESTSubResp | |
4640 // |<----------------| |
4643 // | |------------->|
4646 // | |<-------------|
4648 // |<----------------| |
4651 // | RESTSubDelReq | |
4652 // |---------------->| |
4655 // | |------------->|
4658 // | |<-------------|
4660 // | RESTSubDelResp| |
4661 // |<----------------| |
4663 //-----------------------------------------------------------------------------
4664 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
4665 CaseBegin("TestRESTInsertSubReqAndSubDelOk")
4667 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4668 Counter{cRestSubReqFromXapp, 1},
4669 Counter{cRestSubRespToXapp, 1},
4670 Counter{cSubReqToE2, 1},
4671 Counter{cSubRespFromE2, 1},
4672 Counter{cRestSubNotifToXapp, 1},
4673 Counter{cRestSubDelReqFromXapp, 1},
4674 Counter{cSubDelReqToE2, 1},
4675 Counter{cSubDelRespFromE2, 1},
4676 Counter{cRestSubDelRespToXapp, 1},
4679 const subReqCount int = 1
4681 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4682 params.SetSubActionTypes("insert")
4685 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4688 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4690 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4691 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4693 // Wait that subs is cleaned
4694 waitSubsCleanup(t, e2SubsId, 10)
4695 mainCtrl.VerifyCounterValues(t)
4698 //-----------------------------------------------------------------------------
4699 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
4702 // +-------+ +---------+ +---------+
4703 // | xapp | | submgr | | e2term |
4704 // +-------+ +---------+ +---------+
4707 // |------------->| |
4710 // | |------------->|
4715 // | Submgr restart |
4719 // | |------------->|
4722 // | |<-------------|
4725 //-----------------------------------------------------------------------------
4726 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
4727 CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle")
4729 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4730 Counter{cRestSubReqFromXapp, 1},
4731 Counter{cRestSubRespToXapp, 1},
4732 Counter{cSubReqToE2, 1},
4733 Counter{cSubDelReqFromXapp, 1},
4734 Counter{cSubDelReqToE2, 1},
4735 Counter{cSubDelRespFromE2, 1},
4738 const subReqCount int = 1
4740 // Remove possible existing subscription
4741 mainCtrl.removeExistingSubscriptions(t)
4743 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4746 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
4747 restSubId := xappConn1.SendRESTSubsReq(t, params)
4748 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
4750 e2termConn1.RecvSubsReq(t)
4752 mainCtrl.SetResetTestFlag(t, false)
4754 mainCtrl.SimulateRestart(t)
4755 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4758 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4759 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4761 xappConn1.TestMsgChanEmpty(t)
4762 xappConn2.TestMsgChanEmpty(t)
4763 e2termConn1.TestMsgChanEmpty(t)
4764 mainCtrl.wait_registry_empty(t, 10)
4766 mainCtrl.VerifyCounterValues(t)
4769 //-----------------------------------------------------------------------------
4770 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
4773 // +-------+ +---------+ +---------+
4774 // | xapp | | submgr | | e2term |
4775 // +-------+ +---------+ +---------+
4778 // |---------------->| |
4780 // | RESTSubResp | |
4781 // |<----------------| |
4783 // | |------------->|
4786 // | |<-------------|
4789 // |<----------------| |
4792 // | Submgr restart |
4794 // | RESTSubDelReq | |
4795 // |---------------->| |
4798 // | |------------->|
4801 // | |<-------------|
4803 // | RESTSubDelResp | |
4804 // |<----------------| |
4806 //-----------------------------------------------------------------------------
4808 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
4809 CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle")
4811 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4812 Counter{cRestSubReqFromXapp, 1},
4813 Counter{cRestSubRespToXapp, 1},
4814 Counter{cSubReqToE2, 1},
4815 Counter{cSubRespFromE2, 1},
4816 Counter{cRestSubNotifToXapp, 1},
4817 Counter{cRestSubDelReqFromXapp, 1},
4818 Counter{cSubDelReqToE2, 1},
4819 Counter{cRestSubDelRespToXapp, 1},
4822 // Remove possible existing subscription
4823 mainCtrl.removeExistingSubscriptions(t)
4825 var params *teststube2ap.RESTSubsReqParams = nil
4827 // Create subscription
4828 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4829 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
4831 // Check subscription
4832 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4834 // When SDL support for the REST Interface is added
4835 // the submgr restart statement below should be removed
4836 // from the comment.
4838 // mainCtrl.SimulateRestart(t)
4839 // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4841 // Check subscription
4842 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4844 // Delete subscription
4845 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
4847 //Wait that subs is cleaned
4848 waitSubsCleanup(t, e2SubsId, 10)
4850 mainCtrl.VerifyCounterValues(t)
4853 //-----------------------------------------------------------------------------
4854 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
4857 // +-------+ +-------+ +---------+ +---------+
4858 // | xapp2 | | xapp1 | | submgr | | e2term |
4859 // +-------+ +-------+ +---------+ +---------+
4861 // | | RESTSubReq1 | |
4862 // | |---------------->| |
4864 // | | RESTSubResp1 | |
4865 // | |<----------------| |
4868 // | | |------------->|
4870 // | | |<-------------|
4871 // | | RESTNotif1 | |
4872 // | |<----------------| |
4874 // | RESTSubReq2 | |
4875 // |------------------------------>| |
4877 // | RESTSubResp2 | |
4878 // |<------------------------------| |
4880 // | | RESTNotif2 | |
4881 // |<------------------------------| |
4883 // | | Submgr restart |
4885 // | | RESTSubDelReq1 | |
4886 // | |---------------->| |
4888 // | | RESTSubDelResp1 | |
4889 // | |<----------------| |
4891 // | | Submgr restart |
4893 // | RESTSubDelReq2 | |
4894 // |------------------------------>| |
4896 // | RESTSubDelResp2 | |
4897 // |<------------------------------| |
4899 // | | | SubDelReq2 |
4900 // | | |------------->|
4902 // | | | SubDelResp2 |
4903 // | | |<-------------|
4906 //-----------------------------------------------------------------------------
4908 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
4909 CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
4911 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4912 Counter{cRestSubReqFromXapp, 2},
4913 Counter{cRestSubRespToXapp, 2},
4914 Counter{cSubReqToE2, 1},
4915 Counter{cSubRespFromE2, 1},
4916 Counter{cRestSubNotifToXapp, 2},
4917 Counter{cMergedSubscriptions, 1},
4918 Counter{cUnmergedSubscriptions, 1},
4919 Counter{cRestSubDelReqFromXapp, 2},
4920 Counter{cSubDelReqToE2, 1},
4921 Counter{cSubDelRespFromE2, 1},
4922 Counter{cRestSubDelRespToXapp, 2},
4925 // Remove possible existing subscription
4926 mainCtrl.removeExistingSubscriptions(t)
4928 var params *teststube2ap.RESTSubsReqParams = nil
4930 // Create subscription 1
4931 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4932 xapp.Logger.Info("Send REST subscriber request for subscriber 1 : %v", restSubId1)
4934 // Create subscription 2 with same action
4935 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4936 params.SetMeid("RAN_NAME_1")
4937 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4938 xappConn2.ExpectAnyNotification(t)
4939 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4940 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4941 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
4942 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
4944 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
4946 // When SDL support for the REST Interface is added
4947 // the submgr restart statement below should be removed
4948 // from the comment.
4950 // mainCtrl.SimulateRestart(t)
4951 // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4953 // Delete subscription 1, and wait until it has removed the first endpoint
4954 subepcnt := mainCtrl.get_subs_entrypoint_cnt(t, e2SubsId1)
4955 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4956 mainCtrl.wait_subs_entrypoint_cnt_change(t, e2SubsId1, subepcnt, 10)
4958 // When SDL support for the REST Interface is added
4959 // the submgr restart statement below should be removed
4960 // from the comment.
4962 // mainCtrl.SimulateRestart(t)
4963 // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4964 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
4966 // Delete subscription 2
4967 deleteXapp2Subscription(t, &restSubId2)
4969 //Wait that subs is cleaned
4970 waitSubsCleanup(t, e2SubsId2, 10)
4972 mainCtrl.VerifyCounterValues(t)
4975 //-----------------------------------------------------------------------------
4976 // TestRESTReportSubReqAndSubDelOk
4979 // +-------+ +---------+ +---------+
4980 // | xapp | | submgr | | e2term |
4981 // +-------+ +---------+ +---------+
4984 // |---------------->| |
4986 // | RESTSubResp | |
4987 // |<----------------| |
4990 // | |------------->|
4993 // | |<-------------|
4995 // |<----------------| |
4997 // | |------------->|
5000 // | |<-------------|
5002 // |<----------------| |
5006 // | RESTSubDelReq | |
5007 // |---------------->| |
5010 // | |------------->|
5013 // | |<-------------|
5015 // | RESTSubDelResp| |
5016 // |<----------------| |
5018 //-----------------------------------------------------------------------------
5020 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
5021 CaseBegin("TestRESTReportSubReqAndSubDelOk")
5024 RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
5027 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5028 xapp.Logger.Info("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
5031 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5032 restSubId := xappConn1.SendRESTSubsReq(t, params)
5034 var e2SubsId []uint32
5035 for i := 0; i < subReqCount; i++ {
5036 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5037 xappConn1.ExpectRESTNotification(t, restSubId)
5039 e2termConn1.SendSubsResp(t, crereq, cremsg)
5040 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5041 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5042 e2SubsId = append(e2SubsId, instanceId)
5043 resp, _ := xapp.Subscription.QuerySubscriptions()
5044 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
5045 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
5046 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
5051 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5053 for i := 0; i < subReqCount; i++ {
5054 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5055 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5058 // Wait that subs is cleaned
5059 for i := 0; i < subReqCount; i++ {
5060 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5063 xappConn1.TestMsgChanEmpty(t)
5064 e2termConn1.TestMsgChanEmpty(t)
5065 mainCtrl.wait_registry_empty(t, 10)
5069 func TestRESTPolicySubReqAndSubDelOk(t *testing.T) {
5070 CaseBegin("TestRESTPolicySubReqAndSubDelOk")
5074 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5078 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5081 func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5082 xapp.Logger.Info("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
5085 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5086 restSubId := xappConn1.SendRESTSubsReq(t, params)
5087 //params := xappConn1.GetRESTSubsReqPolicyParams1(subReqCount)
5088 //restSubId := xappConn1.SendRESTPolicySubsReq(t, params)
5090 var e2SubsId []uint32
5091 for i := 0; i < subReqCount; i++ {
5092 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5093 xappConn1.ExpectRESTNotification(t, restSubId)
5094 e2termConn1.SendSubsResp(t, crereq, cremsg)
5095 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5096 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5097 e2SubsId = append(e2SubsId, instanceId)
5101 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5103 for i := 0; i < subReqCount; i++ {
5104 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5105 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5108 // Wait that subs is cleaned
5109 for i := 0; i < subReqCount; i++ {
5110 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5112 xappConn1.TestMsgChanEmpty(t)
5113 e2termConn1.TestMsgChanEmpty(t)
5114 mainCtrl.wait_registry_empty(t, 10)
5117 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
5121 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5122 Counter{cRestSubReqFromXapp, 1},
5123 Counter{cRestSubRespToXapp, 1},
5124 Counter{cSubReqToE2, 2},
5125 Counter{cSubRespFromE2, 2},
5126 Counter{cRestSubNotifToXapp, 2},
5127 Counter{cRestSubDelReqFromXapp, 1},
5128 Counter{cSubDelReqToE2, 2},
5129 Counter{cSubDelRespFromE2, 2},
5130 Counter{cRestSubDelRespToXapp, 1},
5134 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5135 restSubId := xappConn1.SendRESTSubsReq(t, params)
5136 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5138 assert.Equal(t, len(e2SubsIds), 2)
5141 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5142 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5144 xappConn1.TestMsgChanEmpty(t)
5145 e2termConn1.TestMsgChanEmpty(t)
5146 mainCtrl.wait_registry_empty(t, 10)
5148 mainCtrl.VerifyCounterValues(t)
5150 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
5154 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5155 Counter{cRestSubReqFromXapp, 1},
5156 Counter{cRestSubRespToXapp, 1},
5157 Counter{cSubReqToE2, 19},
5158 Counter{cSubRespFromE2, 19},
5159 Counter{cRestSubNotifToXapp, 19},
5160 Counter{cRestSubDelReqFromXapp, 1},
5161 Counter{cSubDelReqToE2, 19},
5162 Counter{cSubDelRespFromE2, 19},
5163 Counter{cRestSubDelRespToXapp, 1},
5167 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5168 restSubId := xappConn1.SendRESTSubsReq(t, params)
5169 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5171 assert.Equal(t, len(e2SubsIds), 19)
5173 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5174 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5176 xappConn1.TestMsgChanEmpty(t)
5177 e2termConn1.TestMsgChanEmpty(t)
5178 mainCtrl.wait_registry_empty(t, 10)
5180 mainCtrl.VerifyCounterValues(t)
5182 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
5186 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5187 Counter{cRestSubReqFromXapp, 1},
5188 Counter{cRestSubRespToXapp, 1},
5189 Counter{cSubReqToE2, uint64(subReqCount)},
5190 Counter{cSubRespFromE2, uint64(subReqCount)},
5191 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5192 Counter{cRestSubDelReqFromXapp, 1},
5193 Counter{cSubDelReqToE2, uint64(subReqCount)},
5194 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5195 Counter{cRestSubDelRespToXapp, 1},
5199 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5200 restSubId := xappConn1.SendRESTSubsReq(t, params)
5201 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5203 assert.Equal(t, len(e2SubsIds), subReqCount)
5206 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5207 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5209 xappConn1.TestMsgChanEmpty(t)
5210 e2termConn1.TestMsgChanEmpty(t)
5211 mainCtrl.wait_registry_empty(t, 10)
5213 mainCtrl.VerifyCounterValues(t)
5216 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
5220 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5221 Counter{cRestSubReqFromXapp, 1},
5222 Counter{cRestSubRespToXapp, 1},
5223 Counter{cSubReqToE2, uint64(subReqCount)},
5224 Counter{cSubRespFromE2, uint64(subReqCount)},
5225 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5226 Counter{cRestSubDelReqFromXapp, 1},
5227 Counter{cSubDelReqToE2, uint64(subReqCount)},
5228 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5229 Counter{cRestSubDelRespToXapp, 1},
5233 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5234 restSubId := xappConn1.SendRESTSubsReq(t, params)
5235 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5237 assert.Equal(t, len(e2SubsIds), subReqCount)
5240 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5241 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5243 xappConn1.TestMsgChanEmpty(t)
5244 e2termConn1.TestMsgChanEmpty(t)
5245 mainCtrl.wait_registry_empty(t, 10)
5247 mainCtrl.VerifyCounterValues(t)
5250 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
5254 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5255 Counter{cRestSubReqFromXapp, 1},
5256 Counter{cRestSubRespToXapp, 1},
5257 Counter{cSubReqToE2, uint64(subReqCount)},
5258 Counter{cSubRespFromE2, uint64(subReqCount)},
5259 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5260 Counter{cRestSubDelReqFromXapp, 1},
5261 Counter{cSubDelReqToE2, uint64(subReqCount)},
5262 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5263 Counter{cRestSubDelRespToXapp, 1},
5267 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5268 restSubId := xappConn1.SendRESTSubsReq(t, params)
5269 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5271 assert.Equal(t, len(e2SubsIds), subReqCount)
5274 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5275 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5277 xappConn1.TestMsgChanEmpty(t)
5278 e2termConn1.TestMsgChanEmpty(t)
5279 mainCtrl.wait_registry_empty(t, 10)
5281 mainCtrl.VerifyCounterValues(t)
5284 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
5285 CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
5287 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5288 Counter{cRestSubReqFromXapp, 2},
5289 Counter{cRestSubRespToXapp, 2},
5290 Counter{cSubReqToE2, 2},
5291 Counter{cSubRespFromE2, 2},
5292 Counter{cRestSubNotifToXapp, 2},
5293 Counter{cRestSubDelReqFromXapp, 2},
5294 Counter{cSubDelReqToE2, 2},
5295 Counter{cSubDelRespFromE2, 2},
5296 Counter{cRestSubDelRespToXapp, 2},
5300 var params *teststube2ap.RESTSubsReqParams = nil
5303 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5304 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5306 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5309 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5310 params.SetMeid("RAN_NAME_1")
5311 eventTriggerDefinition := []int64{1234, 1}
5312 params.SetSubEventTriggerDefinition(eventTriggerDefinition)
5314 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5315 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5316 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5317 xappConn2.ExpectRESTNotification(t, restSubId2)
5318 e2termConn1.SendSubsResp(t, crereq, cremsg)
5319 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5321 deleteXapp1Subscription(t, &restSubId1)
5322 deleteXapp2Subscription(t, &restSubId2)
5324 waitSubsCleanup(t, e2SubsId1, 10)
5325 waitSubsCleanup(t, e2SubsId2, 10)
5327 mainCtrl.VerifyCounterValues(t)
5331 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
5332 CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
5334 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5335 Counter{cRestSubReqFromXapp, 2},
5336 Counter{cRestSubRespToXapp, 2},
5337 Counter{cSubReqToE2, 2},
5338 Counter{cSubRespFromE2, 2},
5339 Counter{cRestSubNotifToXapp, 2},
5340 Counter{cRestSubDelReqFromXapp, 2},
5341 Counter{cSubDelReqToE2, 2},
5342 Counter{cSubDelRespFromE2, 2},
5343 Counter{cRestSubDelRespToXapp, 2},
5347 var params *teststube2ap.RESTSubsReqParams = nil
5350 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5351 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5353 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5356 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5357 params.SetMeid("RAN_NAME_1")
5359 actionId := int64(1)
5360 actionType := "report"
5361 actionDefinition := []int64{5678, 1}
5362 subsequestActionType := "continue"
5363 timeToWait := "w10ms"
5364 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
5366 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5367 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5368 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5369 xappConn2.ExpectRESTNotification(t, restSubId2)
5370 e2termConn1.SendSubsResp(t, crereq, cremsg)
5371 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5373 deleteXapp1Subscription(t, &restSubId1)
5374 deleteXapp2Subscription(t, &restSubId2)
5376 waitSubsCleanup(t, e2SubsId1, 10)
5377 waitSubsCleanup(t, e2SubsId2, 10)
5379 mainCtrl.VerifyCounterValues(t)
5383 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
5384 CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
5386 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5387 Counter{cRestSubReqFromXapp, 2},
5388 Counter{cRestSubRespToXapp, 2},
5389 Counter{cSubReqToE2, 2},
5390 Counter{cSubRespFromE2, 2},
5391 Counter{cRestSubNotifToXapp, 2},
5392 Counter{cRestSubDelReqFromXapp, 2},
5393 Counter{cSubDelReqToE2, 2},
5394 Counter{cSubDelRespFromE2, 2},
5395 Counter{cRestSubDelRespToXapp, 2},
5399 var params *teststube2ap.RESTSubsReqParams = nil
5402 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5403 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5405 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5408 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5409 params.SetMeid("RAN_NAME_1")
5410 params.SetSubActionIDs(int64(2))
5412 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5413 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5414 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5415 xappConn2.ExpectRESTNotification(t, restSubId2)
5416 e2termConn1.SendSubsResp(t, crereq, cremsg)
5417 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5419 deleteXapp1Subscription(t, &restSubId1)
5420 deleteXapp2Subscription(t, &restSubId2)
5422 waitSubsCleanup(t, e2SubsId1, 10)
5423 waitSubsCleanup(t, e2SubsId2, 10)
5425 mainCtrl.VerifyCounterValues(t)
5429 func TestRESTSubReqDiffActionType(t *testing.T) {
5430 CaseBegin("TestRESTSubReqDiffActionType")
5432 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5433 Counter{cRestSubReqFromXapp, 2},
5434 Counter{cRestSubRespToXapp, 2},
5435 Counter{cSubReqToE2, 2},
5436 Counter{cSubRespFromE2, 2},
5437 Counter{cRestSubNotifToXapp, 2},
5438 Counter{cRestSubDelReqFromXapp, 2},
5439 Counter{cSubDelReqToE2, 2},
5440 Counter{cSubDelRespFromE2, 2},
5441 Counter{cRestSubDelRespToXapp, 2},
5445 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5448 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5449 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5451 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5454 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5455 params.SetMeid("RAN_NAME_1")
5457 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5458 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5459 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5460 xappConn2.ExpectRESTNotification(t, restSubId2)
5461 e2termConn1.SendSubsResp(t, crereq, cremsg)
5462 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5464 deleteXapp1Subscription(t, &restSubId1)
5465 deleteXapp2Subscription(t, &restSubId2)
5467 waitSubsCleanup(t, e2SubsId1, 10)
5468 waitSubsCleanup(t, e2SubsId2, 10)
5470 mainCtrl.VerifyCounterValues(t)
5474 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
5475 CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
5477 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5478 Counter{cRestSubReqFromXapp, 2},
5479 Counter{cRestSubRespToXapp, 2},
5480 Counter{cSubReqToE2, 2},
5481 Counter{cSubRespFromE2, 2},
5482 Counter{cRestSubNotifToXapp, 2},
5483 Counter{cRestSubDelReqFromXapp, 2},
5484 Counter{cSubDelReqToE2, 2},
5485 Counter{cSubDelRespFromE2, 2},
5486 Counter{cRestSubDelRespToXapp, 2},
5490 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5493 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5494 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5496 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5499 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
5500 params.SetMeid("RAN_NAME_1")
5502 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5503 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5504 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5505 xappConn2.ExpectRESTNotification(t, restSubId2)
5506 e2termConn1.SendSubsResp(t, crereq, cremsg)
5507 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5509 deleteXapp1Subscription(t, &restSubId1)
5510 deleteXapp2Subscription(t, &restSubId2)
5512 waitSubsCleanup(t, e2SubsId1, 10)
5513 waitSubsCleanup(t, e2SubsId2, 10)
5515 mainCtrl.VerifyCounterValues(t)
5519 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
5520 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
5522 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5523 Counter{cRestSubReqFromXapp, 2},
5524 Counter{cRestSubRespToXapp, 2},
5525 Counter{cSubReqToE2, 2},
5526 Counter{cSubRespFromE2, 2},
5527 Counter{cRestSubNotifToXapp, 2},
5528 Counter{cRestSubDelReqFromXapp, 2},
5529 Counter{cSubDelReqToE2, 2},
5530 Counter{cSubDelRespFromE2, 2},
5531 Counter{cRestSubDelRespToXapp, 2},
5535 var params *teststube2ap.RESTSubsReqParams = nil
5538 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5539 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5541 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5544 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5545 params.SetMeid("RAN_NAME_1")
5546 actionDefinition := []int64{5678, 1}
5547 params.SetSubActionDefinition(actionDefinition)
5549 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5550 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5551 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5552 xappConn2.ExpectRESTNotification(t, restSubId2)
5553 e2termConn1.SendSubsResp(t, crereq, cremsg)
5554 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5556 deleteXapp1Subscription(t, &restSubId1)
5557 deleteXapp2Subscription(t, &restSubId2)
5559 waitSubsCleanup(t, e2SubsId1, 10)
5560 waitSubsCleanup(t, e2SubsId2, 10)
5562 mainCtrl.VerifyCounterValues(t)
5566 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
5567 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
5569 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5570 Counter{cRestSubReqFromXapp, 2},
5571 Counter{cRestSubRespToXapp, 2},
5572 Counter{cSubReqToE2, 2},
5573 Counter{cSubRespFromE2, 2},
5574 Counter{cRestSubNotifToXapp, 2},
5575 Counter{cRestSubDelReqFromXapp, 2},
5576 Counter{cSubDelReqToE2, 2},
5577 Counter{cSubDelRespFromE2, 2},
5578 Counter{cRestSubDelRespToXapp, 2},
5582 var params *teststube2ap.RESTSubsReqParams = nil
5585 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5586 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5588 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5591 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5592 params.SetMeid("RAN_NAME_1")
5593 actionDefinition := []int64{56782}
5594 params.SetSubActionDefinition(actionDefinition)
5596 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5597 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5598 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5599 xappConn2.ExpectRESTNotification(t, restSubId2)
5600 e2termConn1.SendSubsResp(t, crereq, cremsg)
5601 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5603 deleteXapp1Subscription(t, &restSubId1)
5604 deleteXapp2Subscription(t, &restSubId2)
5606 waitSubsCleanup(t, e2SubsId1, 10)
5607 waitSubsCleanup(t, e2SubsId2, 10)
5609 mainCtrl.VerifyCounterValues(t)
5613 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
5614 CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
5616 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5617 Counter{cRestSubReqFromXapp, 2},
5618 Counter{cRestSubRespToXapp, 2},
5619 Counter{cSubReqToE2, 2},
5620 Counter{cSubRespFromE2, 2},
5621 Counter{cRestSubNotifToXapp, 2},
5622 Counter{cRestSubDelReqFromXapp, 2},
5623 Counter{cSubDelReqToE2, 2},
5624 Counter{cSubDelRespFromE2, 2},
5625 Counter{cRestSubDelRespToXapp, 2},
5629 var params *teststube2ap.RESTSubsReqParams = nil
5632 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5633 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5635 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5638 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5639 params.SetMeid("RAN_NAME_1")
5640 params.SetTimeToWait("w200ms")
5641 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5642 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5643 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5644 xappConn2.ExpectRESTNotification(t, restSubId2)
5645 e2termConn1.SendSubsResp(t, crereq, cremsg)
5646 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5648 deleteXapp1Subscription(t, &restSubId1)
5649 deleteXapp2Subscription(t, &restSubId2)
5651 waitSubsCleanup(t, e2SubsId1, 10)
5652 waitSubsCleanup(t, e2SubsId2, 10)
5654 mainCtrl.VerifyCounterValues(t)
5658 //-----------------------------------------------------------------------------
5659 // TestRESTUnpackSubscriptionResponseDecodeFail
5662 // +-------+ +---------+ +---------+
5663 // | xapp | | submgr | | e2term |
5664 // +-------+ +---------+ +---------+
5667 // |---------------->| |
5669 // | RESTSubResp | |
5670 // |<----------------| |
5673 // | |------------->|
5675 // | | SubResp | ASN.1 decode fails
5676 // | |<-------------|
5679 // | |------------->|
5681 // | | SubFail | Duplicated action
5682 // | |<-------------|
5683 // | RESTNotif (fail)| |
5684 // |<----------------| |
5686 // | |------------->|
5689 // | |<-------------|
5691 //-----------------------------------------------------------------------------
5693 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
5694 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
5698 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5699 restSubId := xappConn1.SendRESTSubsReq(t, params)
5701 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5702 // Decode of this response fails which will result resending original request
5703 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
5705 _, cremsg = e2termConn1.RecvSubsReq(t)
5707 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
5709 // Subscription already created in E2 Node.
5710 fparams := &teststube2ap.E2StubSubsFailParams{}
5712 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5713 e2termConn1.SendSubsFail(t, fparams, cremsg)
5715 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5716 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5718 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5719 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5721 // Wait that subs is cleaned
5722 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5724 xappConn1.TestMsgChanEmpty(t)
5725 e2termConn1.TestMsgChanEmpty(t)
5726 mainCtrl.wait_registry_empty(t, 10)
5729 //-----------------------------------------------------------------------------
5730 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
5733 // +-------+ +---------+ +---------+
5734 // | xapp | | submgr | | e2term |
5735 // +-------+ +---------+ +---------+
5738 // |---------------->| |
5740 // | RESTSubResp | |
5741 // |<----------------| |
5744 // | |------------->|
5746 // | | SubResp | Unknown instanceId
5747 // | |<-------------|
5750 // | |------------->|
5752 // | | SubFail | Duplicated action
5753 // | |<-------------|
5754 // | RESTNotif (fail)| |
5755 // |<----------------| |
5757 // | |------------->|
5760 // | |<-------------|
5762 //-----------------------------------------------------------------------------
5764 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
5765 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
5769 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5770 restSubId := xappConn1.SendRESTSubsReq(t, params)
5772 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5774 // Unknown instanceId in this response which will result resending original request
5775 orgInstanceId := crereq.RequestId.InstanceId
5776 crereq.RequestId.InstanceId = 0
5777 e2termConn1.SendSubsResp(t, crereq, cremsg)
5779 _, cremsg = e2termConn1.RecvSubsReq(t)
5781 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
5783 // Subscription already created in E2 Node.
5784 fparams := &teststube2ap.E2StubSubsFailParams{}
5786 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5787 e2termConn1.SendSubsFail(t, fparams, cremsg)
5789 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5790 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5792 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5793 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5795 // Wait that subs is cleaned
5796 mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
5798 xappConn1.TestMsgChanEmpty(t)
5799 e2termConn1.TestMsgChanEmpty(t)
5800 mainCtrl.wait_registry_empty(t, 10)
5803 //-----------------------------------------------------------------------------
5804 // TestRESTUnpackSubscriptionResponseNoTransaction
5807 // +-------+ +---------+ +---------+
5808 // | xapp | | submgr | | e2term |
5809 // +-------+ +---------+ +---------+
5812 // |---------------->| |
5814 // | RESTSubResp | |
5815 // |<----------------| |
5818 // | |------------->|
5820 // | | SubResp | No transaction for the response
5821 // | |<-------------|
5824 // | |------------->|
5826 // | | SubFail | Duplicated action
5827 // | |<-------------|
5828 // | RESTNotif (fail)| |
5829 // |<----------------| |
5831 // | |------------->|
5834 // | |<-------------|
5837 // | |------------->|
5840 // | |<-------------|
5842 //-----------------------------------------------------------------------------
5843 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
5844 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
5848 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5849 restSubId := xappConn1.SendRESTSubsReq(t, params)
5851 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5853 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
5854 // No transaction exist for this response which will result resending original request
5855 e2termConn1.SendSubsResp(t, crereq, cremsg)
5857 _, cremsg = e2termConn1.RecvSubsReq(t)
5859 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
5861 // Subscription already created in E2 Node.
5862 fparams := &teststube2ap.E2StubSubsFailParams{}
5864 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5865 e2termConn1.SendSubsFail(t, fparams, cremsg)
5867 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5868 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5870 // Resending happens because there no transaction
5871 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5872 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5874 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5875 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5877 // Wait that subs is cleaned
5878 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5880 xappConn1.TestMsgChanEmpty(t)
5881 e2termConn1.TestMsgChanEmpty(t)
5882 mainCtrl.wait_registry_empty(t, 10)
5886 //-----------------------------------------------------------------------------
5887 // TestRESTUnpackSubscriptionFailureDecodeFail
5890 // +-------+ +---------+ +---------+
5891 // | xapp | | submgr | | e2term |
5892 // +-------+ +---------+ +---------+
5895 // |---------------->| |
5897 // | RESTSubResp | |
5898 // |<----------------| |
5901 // | |------------->|
5903 // | | SubFail | ASN.1 decode fails
5904 // | |<-------------|
5907 // | |------------->|
5909 // | | SubFail | Duplicated action
5910 // | |<-------------|
5911 // | RESTNotif (fail)| |
5912 // |<----------------| |
5914 // | |------------->|
5917 // | |<-------------|
5919 //-----------------------------------------------------------------------------
5920 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
5921 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
5925 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5926 restSubId := xappConn1.SendRESTSubsReq(t, params)
5928 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5930 // Decode of this response fails which will result resending original request
5931 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
5933 _, cremsg = e2termConn1.RecvSubsReq(t)
5935 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
5937 // Subscription already created in E2 Node.
5938 fparams := &teststube2ap.E2StubSubsFailParams{}
5940 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5941 e2termConn1.SendSubsFail(t, fparams, cremsg)
5943 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5944 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5946 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5947 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5949 // Wait that subs is cleaned
5950 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5952 xappConn1.TestMsgChanEmpty(t)
5953 e2termConn1.TestMsgChanEmpty(t)
5954 mainCtrl.wait_registry_empty(t, 10)
5957 //-----------------------------------------------------------------------------
5958 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
5961 // +-------+ +---------+ +---------+
5962 // | xapp | | submgr | | e2term |
5963 // +-------+ +---------+ +---------+
5966 // |---------------->| |
5968 // | RESTSubResp | |
5969 // |<----------------| |
5972 // | |------------->|
5974 // | | SubFail | Unknown instanceId
5975 // | |<-------------|
5978 // | |------------->|
5980 // | | SubFail | Duplicated action
5981 // | |<-------------|
5982 // | RESTNotif (fail)| |
5983 // |<----------------| |
5985 // | |------------->|
5988 // | |<-------------|
5990 //-----------------------------------------------------------------------------
5991 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
5992 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
5996 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5997 restSubId := xappConn1.SendRESTSubsReq(t, params)
5999 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6001 // Unknown instanceId in this response which will result resending original request
6002 fparams := &teststube2ap.E2StubSubsFailParams{}
6004 fparams.Fail.RequestId.InstanceId = 0
6005 e2termConn1.SendSubsFail(t, fparams, cremsg)
6007 _, cremsg = e2termConn1.RecvSubsReq(t)
6009 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6011 // Subscription already created in E2 Node.
6012 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6013 e2termConn1.SendSubsFail(t, fparams, cremsg)
6015 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6016 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6018 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6019 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
6021 // Wait that subs is cleaned
6022 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6024 xappConn1.TestMsgChanEmpty(t)
6025 e2termConn1.TestMsgChanEmpty(t)
6026 mainCtrl.wait_registry_empty(t, 10)
6029 //-----------------------------------------------------------------------------
6030 // TestRESTUnpackSubscriptionFailureNoTransaction
6033 // +-------+ +---------+ +---------+
6034 // | xapp | | submgr | | e2term |
6035 // +-------+ +---------+ +---------+
6038 // |---------------->| |
6040 // | RESTSubResp | |
6041 // |<----------------| |
6044 // | |------------->|
6046 // | | SubFail | No transaction for the response
6047 // | |<-------------|
6050 // | |------------->|
6052 // | | SubFail | Duplicated action
6053 // | |<-------------|
6054 // | RESTNotif (fail)| |
6055 // |<----------------| |
6057 // | |------------->|
6060 // | |<-------------|
6062 //-----------------------------------------------------------------------------
6063 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
6064 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
6068 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6069 restSubId := xappConn1.SendRESTSubsReq(t, params)
6071 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6073 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6075 // No transaction exist for this response which will result resending original request
6076 fparams := &teststube2ap.E2StubSubsFailParams{}
6078 e2termConn1.SendSubsFail(t, fparams, cremsg)
6080 _, cremsg = e2termConn1.RecvSubsReq(t)
6082 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6084 // Subscription already created in E2 Node.
6085 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6086 e2termConn1.SendSubsFail(t, fparams, cremsg)
6088 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6089 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6091 // Resending happens because there no transaction
6092 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6093 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6095 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6096 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
6098 // Wait that subs is cleaned
6099 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6101 xappConn1.TestMsgChanEmpty(t)
6102 e2termConn1.TestMsgChanEmpty(t)
6103 mainCtrl.wait_registry_empty(t, 10)
6106 //-----------------------------------------------------------------------------
6107 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
6110 // +-------+ +---------+ +---------+
6111 // | xapp | | submgr | | e2term |
6112 // +-------+ +---------+ +---------+
6114 // | [SUBS CREATE] |
6117 // | RESTSubDelReq | |
6118 // |---------------->| |
6120 // | RESTSubDelResp | |
6121 // |<----------------| |
6124 // | |------------->|
6126 // | | SubDelResp | ASN.1 decode fails
6127 // | |<-------------|
6130 // | |------------->|
6132 // | | SubDelFail | Subscription does exist any more
6133 // | |<-------------|
6136 //-----------------------------------------------------------------------------
6137 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
6138 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail")
6141 var params *teststube2ap.RESTSubsReqParams = nil
6142 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6145 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6147 // E2t: Receive 1st SubsDelReq
6148 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6150 // Decode of this response fails which will result resending original request
6151 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_REQ)
6153 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6154 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6156 // Subscription does not exist in in E2 Node.
6157 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6159 // Wait that subs is cleaned
6160 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6162 xappConn1.TestMsgChanEmpty(t)
6163 e2termConn1.TestMsgChanEmpty(t)
6164 mainCtrl.wait_registry_empty(t, 10)
6167 //-----------------------------------------------------------------------------
6168 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
6171 // +-------+ +---------+ +---------+
6172 // | xapp | | submgr | | e2term |
6173 // +-------+ +---------+ +---------+
6175 // | [SUBS CREATE] |
6178 // | RESTSubDelReq | |
6179 // |---------------->| |
6181 // | RESTSubDelResp | |
6182 // |<----------------| |
6185 // | |------------->|
6187 // | | SubDelResp | Unknown instanceId
6188 // | |<-------------|
6191 // | |------------->|
6193 // | | SubDelFail | Subscription does exist any more
6194 // | |<-------------|
6196 //-----------------------------------------------------------------------------
6197 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
6198 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId")
6201 var params *teststube2ap.RESTSubsReqParams = nil
6202 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6205 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6207 // E2t: Receive 1st SubsDelReq
6208 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6210 // Unknown instanceId in this response which will result resending original request
6211 delreq.RequestId.InstanceId = 0
6212 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6214 // E2t: Receive 2nd SubsDelReq
6215 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6217 // Subscription does not exist in in E2 Node.
6218 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6220 // Wait that subs is cleaned
6221 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6223 xappConn1.TestMsgChanEmpty(t)
6224 e2termConn1.TestMsgChanEmpty(t)
6225 mainCtrl.wait_registry_empty(t, 10)
6228 //-----------------------------------------------------------------------------
6229 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
6232 // +-------+ +---------+ +---------+
6233 // | xapp | | submgr | | e2term |
6234 // +-------+ +---------+ +---------+
6236 // | [SUBS CREATE] |
6239 // | RESTSubDelReq | |
6240 // |---------------->| |
6242 // | RESTSubDelResp | |
6243 // |<----------------| |
6246 // | |------------->|
6248 // | | SubDelResp | No transaction for the response
6249 // | |<-------------|
6252 // | |------------->|
6254 // | | SubDelFail | Subscription does exist any more
6255 // | |<-------------|
6257 //-----------------------------------------------------------------------------
6258 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
6259 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction")
6262 var params *teststube2ap.RESTSubsReqParams = nil
6263 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6266 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6268 // E2t: Receive 1st SubsDelReq
6269 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6271 mainCtrl.MakeTransactionNil(t, e2SubsId)
6273 // No transaction exist for this response which will result resending original request
6274 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6276 // E2t: Receive 2nd SubsDelReq
6277 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6279 // Subscription does not exist in in E2 Node.
6280 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6282 // Wait that subs is cleaned
6283 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6285 xappConn1.TestMsgChanEmpty(t)
6286 e2termConn1.TestMsgChanEmpty(t)
6287 mainCtrl.wait_registry_empty(t, 10)
6290 //-----------------------------------------------------------------------------
6291 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
6294 // +-------+ +---------+ +---------+
6295 // | xapp | | submgr | | e2term |
6296 // +-------+ +---------+ +---------+
6298 // | [SUBS CREATE] |
6301 // | RESTSubDelReq | |
6302 // |---------------->| |
6304 // | RESTSubDelResp | |
6305 // |<----------------| |
6308 // | |------------->|
6310 // | | SubDelFail | ASN.1 decode fails
6311 // | |<-------------|
6314 // | |------------->|
6316 // | | SubDelFail | Subscription does exist any more
6317 // | |<-------------|
6319 //-----------------------------------------------------------------------------
6320 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
6321 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail")
6324 var params *teststube2ap.RESTSubsReqParams = nil
6325 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6328 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6330 // E2t: Receive 1st SubsDelReq
6331 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6333 // Decode of this response fails which will result resending original request
6334 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
6336 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6337 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6339 // Subscription does not exist in in E2 Node.
6340 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6342 // Wait that subs is cleaned
6343 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6345 xappConn1.TestMsgChanEmpty(t)
6346 e2termConn1.TestMsgChanEmpty(t)
6347 mainCtrl.wait_registry_empty(t, 10)
6350 //-----------------------------------------------------------------------------
6351 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
6354 // +-------+ +---------+ +---------+
6355 // | xapp | | submgr | | e2term |
6356 // +-------+ +---------+ +---------+
6358 // | [SUBS CREATE] |
6361 // | RESTSubDelReq | |
6362 // |---------------->| |
6364 // | RESTSubDelResp | |
6365 // |<----------------| |
6368 // | |------------->|
6370 // | | SubDelFail | Unknown instanceId
6371 // | |<-------------|
6374 // | |------------->|
6376 // | | SubDelFail | Subscription does exist any more
6377 // | |<-------------|
6379 //-----------------------------------------------------------------------------
6380 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
6381 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId")
6384 var params *teststube2ap.RESTSubsReqParams = nil
6385 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6388 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6390 // E2t: Receive 1st SubsDelReq
6391 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6393 // Unknown instanceId in this response which will result resending original request
6394 delreq.RequestId.InstanceId = 0
6395 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6397 // E2t: Receive 2nd SubsDelReq
6398 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6400 // Subscription does not exist in in E2 Node.
6401 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6403 // Wait that subs is cleaned
6404 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6406 xappConn1.TestMsgChanEmpty(t)
6407 e2termConn1.TestMsgChanEmpty(t)
6408 mainCtrl.wait_registry_empty(t, 10)
6411 //-----------------------------------------------------------------------------
6412 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
6415 // +-------+ +---------+ +---------+
6416 // | xapp | | submgr | | e2term |
6417 // +-------+ +---------+ +---------+
6419 // | [SUBS CREATE] |
6422 // | RESTSubDelReq | |
6423 // |---------------->| |
6425 // | RESTSubDelResp | |
6426 // |<----------------| |
6429 // | |------------->|
6431 // | | SubDelFail | No transaction for the response
6432 // | |<-------------|
6435 // | |------------->|
6437 // | | SubDelFail | Subscription does exist any more
6438 // | |<-------------|
6440 //-----------------------------------------------------------------------------
6441 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
6442 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction")
6445 var params *teststube2ap.RESTSubsReqParams = nil
6446 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6449 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6451 // E2t: Receive 1st SubsDelReq
6452 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6454 mainCtrl.MakeTransactionNil(t, e2SubsId)
6456 // No transaction exist for this response which will result resending original request
6457 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6459 // E2t: Receive 2nd SubsDelReq
6460 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6462 // Subscription does not exist in in E2 Node.
6463 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6465 // Wait that subs is cleaned
6466 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6468 xappConn1.TestMsgChanEmpty(t)
6469 e2termConn1.TestMsgChanEmpty(t)
6470 mainCtrl.wait_registry_empty(t, 10)
6473 //-----------------------------------------------------------------------------
6474 // TestRESTSubReqFailAsn1PackSubReqError
6477 // +-------+ +---------+ +---------+
6478 // | xapp | | submgr | | e2term |
6479 // +-------+ +---------+ +---------+
6482 // |---------------->| |
6484 // | RESTSubResp | |
6485 // |<----------------| |
6487 // | ASN.1 encode fails |
6490 // | |------------->|
6493 // | |<-------------|
6497 // |<----------------| |
6499 // | [SUBS DELETE] |
6502 //-----------------------------------------------------------------------------
6503 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
6505 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6506 Counter{cRestSubReqFromXapp, 1},
6507 Counter{cRestSubRespToXapp, 1},
6508 Counter{cSubDelReqToE2, 1},
6509 Counter{cSubDelFailFromE2, 1},
6510 Counter{cRestSubFailNotifToXapp, 1},
6515 var params *teststube2ap.RESTSubsReqParams = nil
6516 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
6517 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
6520 restSubId := xappConn1.SendRESTSubsReq(t, params)
6521 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
6523 // E2t: Receive SubsDelReq
6524 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6525 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6527 // Subscription does not exist in in E2 Node.
6528 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6530 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6531 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
6533 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
6534 // Wait that subs is cleaned
6535 waitSubsCleanup(t, e2SubsId, 10)
6536 mainCtrl.VerifyCounterValues(t)
6539 ////////////////////////////////////////////////////////////////////////////////////
6540 // Services for UT cases
6541 ////////////////////////////////////////////////////////////////////////////////////
6542 const subReqCount int = 1
6543 const host string = "localhost"
6545 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
6547 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
6549 restSubId := fromXappConn.SendRESTSubsReq(t, params)
6550 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
6552 crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
6553 fromXappConn.ExpectRESTNotification(t, restSubId)
6554 toE2termConn.SendSubsResp(t, crereq1, cremsg1)
6555 e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
6556 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
6558 return restSubId, e2SubsId
6561 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
6563 params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
6565 params.SetMeid(meid)
6567 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
6568 restSubId := xappConn2.SendRESTSubsReq(t, params)
6569 xappConn2.ExpectRESTNotification(t, restSubId)
6570 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
6571 e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
6572 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
6574 return restSubId, e2SubsId
6577 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
6578 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6579 restSubId := xappConn1.SendRESTSubsReq(t, params)
6580 xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
6582 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6583 xappConn1.ExpectRESTNotification(t, restSubId)
6584 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
6585 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6586 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
6588 return restSubId, e2SubsId
6591 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
6592 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6593 restSubId := xappConn1.SendRESTSubsReq(t, params)
6595 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6596 fparams1 := &teststube2ap.E2StubSubsFailParams{}
6597 fparams1.Set(crereq1)
6598 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
6600 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
6601 xappConn1.ExpectRESTNotification(t, restSubId)
6602 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
6603 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6604 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
6606 return restSubId, e2SubsId
6609 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
6610 fromXappConn.SendRESTSubsDelReq(t, restSubId)
6611 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
6612 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
6615 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
6616 xappConn1.SendRESTSubsDelReq(t, restSubId)
6617 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6618 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6621 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
6622 xappConn2.SendRESTSubsDelReq(t, restSubId)
6623 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6624 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6627 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
6628 resp, _ := xapp.Subscription.QuerySubscriptions()
6629 assert.Equal(t, resp[0].SubscriptionID, e2SubsId)
6630 assert.Equal(t, resp[0].Meid, meid)
6631 assert.Equal(t, resp[0].ClientEndpoint, endpoint)
6634 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
6635 //Wait that subs is cleaned
6636 mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
6638 xappConn1.TestMsgChanEmpty(t)
6639 xappConn2.TestMsgChanEmpty(t)
6640 e2termConn1.TestMsgChanEmpty(t)
6641 mainCtrl.wait_registry_empty(t, timeout)
6644 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
6646 var e2SubsId []uint32
6648 for i := 0; i < count; i++ {
6649 xapp.Logger.Info("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
6650 crereq, cremsg := toE2termConn.RecvSubsReq(t)
6651 fromXappConn.ExpectRESTNotification(t, restSubId)
6652 toE2termConn.SendSubsResp(t, crereq, cremsg)
6653 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
6654 e2SubsId = append(e2SubsId, instanceId)
6655 xapp.Logger.Info("TEST: %v", e2SubsId)
6656 xapp.Logger.Info("TEST: %d ===================================== END CRE ============================================", i+1)
6657 <-time.After(100 * time.Millisecond)
6662 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
6664 for i := 0; i < len(e2SubsIds); i++ {
6665 xapp.Logger.Info("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
6666 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
6667 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
6668 <-time.After(1 * time.Second)
6669 xapp.Logger.Info("TEST: %d ===================================== END DEL ============================================", i+1)
6670 <-time.After(100 * time.Millisecond)
6673 // Wait that subs is cleaned
6674 for i := 0; i < len(e2SubsIds); i++ {
6675 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)