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 func TestGetRestSubscriptions(t *testing.T) {
2375 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/restsubscriptions")
2378 //-----------------------------------------------------------------------------
2379 // TestRESTSubReqAndRouteNok
2382 // +-------+ +---------+ +---------+
2383 // | xapp | | submgr | | rtmgr |
2384 // +-------+ +---------+ +---------+
2387 // |---------------->| |
2389 // | RESTSubResp | |
2390 // |<----------------| |
2391 // | | RouteCreate |
2392 // | |------------->|
2394 // | | RouteCreate |
2396 // | |(Bad request) |
2397 // | |<-------------|
2399 // |<----------------| |
2401 // | [SUBS INT DELETE] |
2403 // | RESTSubDelReq | |
2404 // |---------------->| |
2405 // | RESTSubDelResp | |
2406 // |<----------------| |
2408 //-----------------------------------------------------------------------------
2409 func TestRESTSubReqAndRouteNok(t *testing.T) {
2410 CaseBegin("TestRESTSubReqAndRouteNok")
2412 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2413 Counter{cRestSubReqFromXapp, 1},
2414 Counter{cRestSubRespToXapp, 1},
2415 Counter{cRouteCreateFail, 1},
2416 Counter{cRestSubFailNotifToXapp, 1},
2417 Counter{cRestSubDelReqFromXapp, 1},
2418 Counter{cRestSubDelRespToXapp, 1},
2421 const subReqCount int = 1
2422 // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
2423 waiter := rtmgrHttp.AllocNextSleep(50, false)
2424 newSubsId := mainCtrl.get_registry_next_subid(t)
2427 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2428 restSubId := xappConn1.SendRESTSubsReq(t, params)
2429 xappConn1.ExpectRESTNotificationNok(t, restSubId, "failAll")
2430 waiter.WaitResult(t)
2432 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2433 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
2436 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2438 // Wait that subs is cleaned
2439 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2440 waitSubsCleanup(t, e2SubsId, 10)
2441 mainCtrl.VerifyCounterValues(t)
2444 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
2445 CaseBegin("TestSubReqAndRouteUpdateNok")
2447 //Init counter check
2448 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2449 Counter{cRestSubReqFromXapp, 2},
2450 Counter{cRestSubRespToXapp, 2},
2451 Counter{cSubReqToE2, 1},
2452 Counter{cSubRespFromE2, 1},
2453 Counter{cRestSubNotifToXapp, 1},
2454 Counter{cRestSubFailNotifToXapp, 1},
2455 Counter{cRouteCreateUpdateFail, 1},
2456 Counter{cRestSubDelReqFromXapp, 1},
2457 Counter{cSubDelReqToE2, 1},
2458 Counter{cSubDelRespFromE2, 1},
2459 Counter{cRestSubDelRespToXapp, 1},
2462 var params *teststube2ap.RESTSubsReqParams = nil
2465 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2467 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2469 // xapp2 ROUTE creation shall fail with 400 from rtmgr -> submgr
2470 waiter := rtmgrHttp.AllocNextEvent(false)
2471 newSubsId := mainCtrl.get_registry_next_subid(t)
2472 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
2473 params.SetMeid("RAN_NAME_1")
2474 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2475 xapp.Logger.Info("Send REST subscriber request for second subscriber : %v", restSubId2)
2476 xappConn2.ExpectRESTNotificationNok(t, restSubId2, "allFail")
2477 waiter.WaitResult(t)
2478 // e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) - TOD: missing delete
2479 xappConn2.WaitRESTNotification(t, restSubId2)
2481 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2483 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2485 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2486 //Wait that subs is cleaned
2487 waitSubsCleanup(t, e2SubsId, 10)
2489 mainCtrl.VerifyCounterValues(t)
2492 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
2493 CaseBegin("TestRESTSubDelReqAndRouteDeleteNok")
2495 // Init counter check
2496 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2497 Counter{cRestSubReqFromXapp, 1},
2498 Counter{cRestSubRespToXapp, 1},
2499 Counter{cSubReqToE2, 1},
2500 Counter{cSubRespFromE2, 1},
2501 Counter{cRestSubNotifToXapp, 1},
2502 Counter{cRestSubDelReqFromXapp, 1},
2503 Counter{cRouteDeleteFail, 1},
2504 Counter{cSubDelReqToE2, 1},
2505 Counter{cSubDelRespFromE2, 1},
2506 Counter{cRestSubDelRespToXapp, 1},
2509 var params *teststube2ap.RESTSubsReqParams = nil
2512 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2514 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2516 waiter := rtmgrHttp.AllocNextEvent(false)
2517 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2518 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2519 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2520 waiter.WaitResult(t)
2522 waitSubsCleanup(t, e2SubsId, 10)
2524 mainCtrl.VerifyCounterValues(t)
2527 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
2528 CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok")
2530 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2531 Counter{cRestSubReqFromXapp, 2},
2532 Counter{cRestSubRespToXapp, 2},
2533 Counter{cSubReqToE2, 1},
2534 Counter{cSubRespFromE2, 1},
2535 Counter{cRestSubNotifToXapp, 2},
2536 Counter{cRestSubDelReqFromXapp, 2},
2537 Counter{cRouteDeleteUpdateFail, 1},
2538 Counter{cSubDelReqToE2, 1},
2539 Counter{cSubDelRespFromE2, 1},
2540 Counter{cRestSubDelRespToXapp, 2},
2543 var params *teststube2ap.RESTSubsReqParams = nil
2546 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2548 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2549 restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1")
2551 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
2553 //Del1, this shall fail on rtmgr side
2554 waiter := rtmgrHttp.AllocNextEvent(false)
2555 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2556 waiter.WaitResult(t)
2558 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"})
2561 deleteXapp2Subscription(t, &restSubId2)
2563 waitSubsCleanup(t, e2SubsId2, 10)
2565 mainCtrl.VerifyCounterValues(t)
2568 //-----------------------------------------------------------------------------
2569 // TestRESTSubReqRetransmission
2572 // +-------+ +---------+ +---------+
2573 // | xapp | | submgr | | e2term |
2574 // +-------+ +---------+ +---------+
2576 // | RESTSubReq1 | |
2577 // |---------------->| |
2579 // | RESTSubResp | |
2580 // |<----------------| |
2582 // | |------------->|
2584 // | RESTSubReq2 | |
2586 // |---------------->| |
2587 // | RESTSubResp(201)| |
2588 // |<----------------| |
2591 // | |<-------------|
2593 // |<----------------| |
2595 // | [SUBS DELETE] |
2598 //-----------------------------------------------------------------------------
2600 func TestRESTSubReqRetransmission(t *testing.T) {
2601 CaseBegin("TestRESTSubReqRetransmission")
2603 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2604 Counter{cRestSubReqFromXapp, 2},
2605 Counter{cRestSubRespToXapp, 2},
2606 Counter{cSubReqToE2, 1},
2607 Counter{cSubRespFromE2, 1},
2608 Counter{cRestSubNotifToXapp, 1},
2609 Counter{cRestSubDelReqFromXapp, 1},
2610 Counter{cSubDelReqToE2, 1},
2611 Counter{cSubDelRespFromE2, 1},
2612 Counter{cRestSubDelRespToXapp, 1},
2614 // Retry/duplicate will get the same way as the first request.
2615 // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
2616 // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
2619 const subReqCount int = 1
2621 // In order to force both XAPP's to create their own subscriptions, force rtmgr to block a while so that 2nd create
2622 // gets into execution before the rtmgrg responds for the first one.
2623 waiter := rtmgrHttp.AllocNextSleep(10, true)
2624 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2625 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
2626 xappConn2.SendRESTSubsReq(t, params)
2628 waiter.WaitResult(t)
2630 xappConn1.WaitListedRestNotifications(t, []string{restSubId1})
2632 // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
2633 // the order is not significant he6re.
2634 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2635 e2termConn1.SendSubsResp(t, crereq, cremsg)
2637 e2SubsIdA := <-xappConn1.ListedRESTNotifications
2638 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
2641 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
2642 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2643 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2645 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId}, 10)
2647 mainCtrl.VerifyCounterValues(t)
2650 //-----------------------------------------------------------------------------
2652 // +-------+ +---------+ +---------+ +---------+
2653 // | xapp | | submgr | | e2term | | rtmgr |
2654 // +-------+ +---------+ +---------+ +---------+
2656 // | RESTSubReq | | |
2657 // |---------------->| | |
2658 // | RESTSubResp | | |
2659 // |<----------------| | |
2660 // | | RouteCreate | |
2661 // | |--------------------------->|
2662 // | | RouteResponse| |
2663 // | |<---------------------------| // The order of these events may vary
2665 // | |------------->| | // The order of these events may vary
2667 // | |<-------------| |
2668 // | RESTNotif1 | | |
2669 // |<----------------| | |
2670 // | RESTSubReq | | |
2671 // | [RETRANS1] | | |
2672 // |---------------->| | |
2673 // | RESTNotif1 | | |
2674 // |<----------------| | |
2675 // | RESTSubReq | | |
2676 // | [RETRANS2] | | |
2677 // |---------------->| | |
2678 // | RESTNotif1 | | |
2679 // |<----------------| | |
2680 // | RESTSubDelReq | | |
2681 // |---------------->| | |
2682 // | | SubDelReq | |
2683 // | |------------->| |
2684 // | RESTSubDelResp| | |
2685 // |<----------------| | |
2686 // | | SubDelResp | |
2687 // | |<-------------| |
2690 //-----------------------------------------------------------------------------
2692 func TestRESTSubReqRetransmissionV2(t *testing.T) {
2693 CaseBegin("TestRESTSubReqRetransmissionV2")
2695 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2696 Counter{cRestSubReqFromXapp, 3},
2697 Counter{cRestSubRespToXapp, 3},
2698 Counter{cSubReqToE2, 1},
2699 Counter{cSubRespFromE2, 1},
2700 Counter{cRestSubNotifToXapp, 3},
2701 Counter{cRestSubDelReqFromXapp, 1},
2702 Counter{cSubDelReqToE2, 1},
2703 Counter{cSubDelRespFromE2, 1},
2704 Counter{cRestSubDelRespToXapp, 1},
2707 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2709 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2711 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2714 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
2716 assert.Equal(t, restSubId_resend, restSubId)
2718 <-time.After(100 * time.Millisecond)
2721 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
2723 assert.Equal(t, restSubId_resend2, restSubId)
2725 <-time.After(100 * time.Millisecond)
2727 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2729 waitSubsCleanup(t, e2SubsId, 10)
2731 //Wait that subs is cleaned
2732 mainCtrl.VerifyCounterValues(t)
2735 //-----------------------------------------------------------------------------
2737 // +-------+ +---------+ +---------+ +---------+
2738 // | xapp | | submgr | | e2term | | rtmgr |
2739 // +-------+ +---------+ +---------+ +---------+
2741 // | RESTSubReq | | |
2742 // |---------------->| | |
2743 // | RESTSubResp | | |
2744 // |<----------------| | |
2745 // | | RouteCreate | |
2746 // | |--------------------------->|
2747 // | | RouteResponse| |
2748 // | |<---------------------------| // The order of these events may vary
2750 // | |------------->| | // The order of these events may vary
2752 // | |<-------------| |
2753 // | RESTNotif1 | | |
2754 // |<----------------| | |
2755 // | RESTSubReq | | |
2756 // | [RETRANS, with RESTsubsId] | |
2757 // |---------------->| | |
2758 // | RESTNotif1 | | |
2759 // |<----------------| | |
2760 // | RESTSubReq | | |
2761 // | [RETRANS, without RESTsubsId] | |
2762 // |---------------->| | |
2763 // | RESTNotif1 | | |
2764 // |<----------------| | |
2765 // | RESTSubDelReq | | |
2766 // |---------------->| | |
2767 // | | SubDelReq | |
2768 // | |------------->| |
2769 // | RESTSubDelResp| | |
2770 // |<----------------| | |
2771 // | | SubDelResp | |
2772 // | |<-------------| |
2775 //-----------------------------------------------------------------------------
2776 func TestRESTSubReqRetransmissionV3(t *testing.T) {
2777 CaseBegin("TestRESTSubReqRetransmissionV3")
2779 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2780 Counter{cRestSubReqFromXapp, 3},
2781 Counter{cRestSubRespToXapp, 3},
2782 Counter{cSubReqToE2, 1},
2783 Counter{cSubRespFromE2, 1},
2784 Counter{cRestSubNotifToXapp, 3},
2785 Counter{cRestSubDelReqFromXapp, 1},
2786 Counter{cSubDelReqToE2, 1},
2787 Counter{cSubDelRespFromE2, 1},
2788 Counter{cRestSubDelRespToXapp, 1},
2791 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2793 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2795 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2797 <-time.After(100 * time.Millisecond)
2799 //1.st resend with subscription ID
2800 params.SetSubscriptionID(&restSubId)
2801 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
2803 assert.Equal(t, restSubId_resend, restSubId)
2805 <-time.After(100 * time.Millisecond)
2807 //2.nd resend without subscription ID (faking app restart)
2808 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
2809 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
2811 assert.Equal(t, restSubId_resend2, restSubId)
2813 <-time.After(100 * time.Millisecond)
2815 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2817 waitSubsCleanup(t, e2SubsId, 10)
2819 //Wait that subs is cleaned
2820 mainCtrl.VerifyCounterValues(t)
2823 //-----------------------------------------------------------------------------
2825 // +-------+ +---------+ +---------+ +---------+
2826 // | xapp | | submgr | | e2term | | rtmgr |
2827 // +-------+ +---------+ +---------+ +---------+
2829 // | RESTSubReq | | |
2830 // |---------------->| | |
2831 // | RESTSubResp | | |
2832 // |<----------------| | |
2833 // | | RouteCreate | |
2834 // | |--------------------------->|
2835 // | | RouteResponse| |
2836 // | |<---------------------------|
2838 // | |------------->| |
2840 // | |<-------------| |
2841 // | RESTNotif1 | | |
2842 // |<----------------| | |
2843 // | RESTSubReq | | |
2844 // | [with RestSUbsId + one additional e2 subDetail]
2845 // |---------------->| | |
2846 // | RESTNotif1 | | |
2847 // | [for initial e2 subDetail] | |
2848 // |<----------------| | |
2849 // | | RouteCreate | |
2850 // | |--------------------------->|
2851 // | | RouteResponse| |
2852 // | |<---------------------------|
2854 // | |------------->| |
2856 // | |<-------------| |
2857 // | RESTNotif1 | | |
2858 // |<----------------| | |
2859 // | RESTSubReq | | |
2860 // | [with RESTsubsId initial request] |
2861 // |---------------->| | |
2862 // | RESTNotif1 | | |
2863 // |<----------------| | |
2864 // | RESTSubDelReq | | |
2865 // |---------------->| | |
2866 // | RESTSubDelResp| | |
2867 // |<----------------| | |
2868 // | | SubDelReq | |
2869 // | |------------->| |
2870 // | | SubDelResp | |
2871 // | |<-------------| |
2872 // | | SubDelReq | |
2873 // | |------------->| |
2874 // | | SubDelResp | |
2875 // | |<-------------| |
2878 //-----------------------------------------------------------------------------
2880 func TestRESTSubReqRetransmissionV4(t *testing.T) {
2881 CaseBegin("TestRESTSubReqRetransmissionV4")
2883 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2884 Counter{cRestSubReqFromXapp, 3},
2885 Counter{cRestSubRespToXapp, 3},
2886 Counter{cSubReqToE2, 2},
2887 Counter{cSubRespFromE2, 2},
2888 Counter{cRestSubNotifToXapp, 4},
2889 Counter{cRestSubDelReqFromXapp, 1},
2890 Counter{cSubDelReqToE2, 2},
2891 Counter{cSubDelRespFromE2, 2},
2892 Counter{cRestSubDelRespToXapp, 1},
2895 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2897 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2899 <-time.After(100 * time.Millisecond)
2901 // Send modified requst, this time with e2 subscriptions.
2902 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
2903 params2.SetSubscriptionID(&restSubId)
2905 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
2906 xappConn1.ExpectAnyNotification(t)
2907 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
2908 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
2909 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
2910 assert.Equal(t, e2SubsId, e2SubsId1)
2912 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
2914 xappConn1.DecrementRequestCount()
2915 xappConn1.ExpectRESTNotification(t, restSubId_resend)
2916 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
2917 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
2918 assert.NotEqual(t, e2SubsId2, 0)
2920 <-time.After(100 * time.Millisecond)
2922 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
2923 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
2924 params.SetSubscriptionID(&restSubId)
2925 xappConn1.ExpectAnyNotification(t)
2926 // Resend the original request again with only one e2 subscription (detail), this time with restsubsid
2927 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
2928 assert.Equal(t, restSubId_resend, restSubId_resend2)
2930 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
2931 assert.Equal(t, e2SubsId, e2SubsId1)
2933 // Delete both e2 subscriptions
2934 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2935 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
2936 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
2938 waitSubsCleanup(t, e2SubsId, 10)
2940 //Wait that subs is cleaned
2941 mainCtrl.VerifyCounterValues(t)
2944 //-----------------------------------------------------------------------------
2946 // +-------+ +---------+ +---------+ +---------+
2947 // | xapp | | submgr | | e2term | | rtmgr |
2948 // +-------+ +---------+ +---------+ +---------+
2950 // | RESTSubReq | | |
2951 // |---------------->| | |
2952 // | RESTSubResp | | |
2953 // |<----------------| | |
2954 // | | RouteCreate | |
2955 // | |--------------------------->|
2956 // | | RouteResponse| |
2957 // | |<---------------------------|
2959 // | |------------->| |
2961 // | |<-------------| |
2962 // | RESTNotif1 | | |
2963 // |<----------------| | |
2964 // | RESTSubReq | | |
2965 // | [with RestSUbsId + one additional e2 subDetail]
2966 // |---------------->| | |
2967 // | RESTNotif1 | | |
2968 // | [for initial e2 subDetail] | |
2969 // |<----------------| | |
2970 // | | RouteCreate | |
2971 // | |--------------------------->|
2972 // | | RouteResponse| |
2973 // | |<---------------------------|
2975 // | |------------->| |
2977 // | |<-------------| |
2978 // | RESTNotif1 | | |
2979 // |<----------------| | |
2980 // | RESTSubReq | | |
2981 // | [without RESTsubsId initial request] |
2982 // |---------------->| | |
2983 // | RESTNotif1 | | |
2984 // |<----------------| | |
2985 // | RESTSubDelReq | | |
2986 // |---------------->| | |
2987 // | RESTSubDelResp| | |
2988 // |<----------------| | |
2989 // | | SubDelReq | |
2990 // | |------------->| |
2991 // | | SubDelResp | |
2992 // | |<-------------| |
2993 // | | SubDelReq | |
2994 // | |------------->| |
2995 // | | SubDelResp | |
2996 // | |<-------------| |
2999 //-----------------------------------------------------------------------------
3001 func TestRESTSubReqRetransmissionV5(t *testing.T) {
3002 CaseBegin("TestRESTSubReqRetransmissionV5")
3004 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3005 Counter{cRestSubReqFromXapp, 3},
3006 Counter{cRestSubRespToXapp, 3},
3007 Counter{cSubReqToE2, 2},
3008 Counter{cSubRespFromE2, 2},
3009 Counter{cRestSubNotifToXapp, 4},
3010 Counter{cRestSubDelReqFromXapp, 1},
3011 Counter{cSubDelReqToE2, 2},
3012 Counter{cSubDelRespFromE2, 2},
3013 Counter{cRestSubDelRespToXapp, 1},
3016 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3018 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3020 <-time.After(100 * time.Millisecond)
3022 // Send modified requst, this time with e2 subscriptions.
3023 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3024 params2.SetSubscriptionID(&restSubId)
3026 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3027 xappConn1.ExpectAnyNotification(t)
3028 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3029 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3031 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3032 assert.Equal(t, e2SubsId, e2SubsId1)
3033 // The first E2 subscription returns immediately, manually decrement expected request count for the remaining request handling
3034 xappConn1.DecrementRequestCount()
3036 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3038 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3039 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3040 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3041 assert.NotEqual(t, e2SubsId2, 0)
3043 <-time.After(100 * time.Millisecond)
3045 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3046 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3047 xappConn1.ExpectAnyNotification(t)
3048 // Resend the original request again with only one e2 subscription (detail), WITHOUT restsubsid
3049 // md5sum shall find the original request
3050 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3051 assert.Equal(t, restSubId_resend, restSubId_resend2)
3053 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3054 assert.Equal(t, e2SubsId, e2SubsId1)
3056 // Delete both e2 subscriptions
3057 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3058 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3059 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3061 waitSubsCleanup(t, e2SubsId, 10)
3063 //Wait that subs is cleaned
3064 mainCtrl.VerifyCounterValues(t)
3067 //-----------------------------------------------------------------------------
3069 // +-------+ +---------+ +---------+ +---------+
3070 // | xapp | | submgr | | e2term | | rtmgr |
3071 // +-------+ +---------+ +---------+ +---------+
3073 // | RESTSubReq | | |
3074 // |---------------->| | |
3075 // | RESTSubResp | | |
3076 // |<----------------| | |
3077 // | | RouteCreate | |
3078 // | |--------------------------->|
3079 // | | RouteResponse| |
3080 // | |<---------------------------|
3082 // | |------------->| |
3084 // | |<-------------| |
3085 // | RESTNotif1 | | |
3086 // |<----------------| | |
3087 // | RESTSubReq | | |
3088 // | [with RestSUbsId + one additional e2 subDetail]
3089 // |---------------->| | |
3090 // | RESTNotif1 | | |
3091 // | [for initial e2 subDetail] | |
3092 // |<----------------| | |
3093 // | | RouteCreate | |
3094 // | |--------------------------->|
3095 // | | RouteResponse| |
3096 // | |<---------------------------|
3098 // | |------------->| |
3100 // | |<-------------| |
3101 // | RESTNotif1 | | |
3102 // |<----------------| | |
3103 // | RESTSubDelReq | | |
3104 // |---------------->| | |
3105 // | RESTSubDelResp| | |
3106 // |<----------------| | |
3107 // | | SubDelReq | |
3108 // | |------------->| |
3109 // | | SubDelResp | |
3110 // | |<-------------| |
3111 // | | SubDelReq | |
3112 // | |------------->| |
3113 // | | SubDelResp | |
3114 // | |<-------------| |
3115 // | RESTSubReq | | |
3116 // | [with RESTsubsId initial request] |
3117 // |---------------->| | |
3118 // | RESTSubResp | | |
3119 // |<----------------| | |
3120 // | | RouteCreate | |
3121 // | |--------------------------->|
3122 // | | RouteResponse| |
3123 // | |<---------------------------|
3125 // | |------------->| |
3127 // | |<-------------| |
3128 // | RESTNotif1 | | |
3129 // |<----------------| | |
3132 //-----------------------------------------------------------------------------
3133 func TestRESTSubReqRetransmissionV6(t *testing.T) {
3134 CaseBegin("TestRESTSubReqRetransmissionV6")
3136 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3137 Counter{cRestSubReqFromXapp, 3},
3138 Counter{cRestSubRespToXapp, 3},
3139 Counter{cSubReqToE2, 3},
3140 Counter{cSubRespFromE2, 3},
3141 Counter{cRestSubNotifToXapp, 4},
3142 Counter{cRestSubDelReqFromXapp, 2},
3143 Counter{cSubDelReqToE2, 3},
3144 Counter{cSubDelRespFromE2, 3},
3145 Counter{cRestSubDelRespToXapp, 2},
3148 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3150 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3152 <-time.After(100 * time.Millisecond)
3154 // Send modified requst, this time with e2 subscriptions.
3155 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3156 params2.SetSubscriptionID(&restSubId)
3158 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3159 xappConn1.ExpectAnyNotification(t)
3160 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3161 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3163 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3164 assert.Equal(t, e2SubsId, e2SubsId1)
3166 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3168 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3169 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3170 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3171 assert.NotEqual(t, e2SubsId2, 0)
3173 <-time.After(100 * time.Millisecond)
3175 // Delete both e2 subscriptions
3176 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3177 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3178 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3180 waitSubsCleanup(t, e2SubsId, 10)
3182 // Resend the original request, we shall find it's previous md5sum/restsubs
3183 // but the restsubscription has been already removed. This shall trigger a
3185 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
3187 <-time.After(100 * time.Millisecond)
3189 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3191 waitSubsCleanup(t, e2SubsId, 10)
3193 //Wait that subs is cleaned
3194 mainCtrl.VerifyCounterValues(t)
3197 func TestRESTSubDelReqRetransmission(t *testing.T) {
3198 CaseBegin("TestRESTSubDelReqRetransmission")
3200 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3201 Counter{cRestSubReqFromXapp, 1},
3202 Counter{cRestSubRespToXapp, 1},
3203 Counter{cSubReqToE2, 1},
3204 Counter{cSubRespFromE2, 1},
3205 Counter{cRestSubNotifToXapp, 1},
3206 Counter{cRestSubDelReqFromXapp, 2},
3207 Counter{cSubDelReqToE2, 1},
3208 Counter{cSubDelRespFromE2, 1},
3209 Counter{cRestSubDelRespToXapp, 1},
3212 var params *teststube2ap.RESTSubsReqParams = nil
3215 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3217 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3220 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3221 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3223 seqBef := mainCtrl.get_msgcounter(t)
3224 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3225 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
3227 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3229 waitSubsCleanup(t, e2SubsId, 10)
3231 mainCtrl.VerifyCounterValues(t)
3234 //-----------------------------------------------------------------------------
3235 // TestRESTSubReqDelReq
3238 // +-------+ +---------+ +---------+
3239 // | xapp | | submgr | | e2term |
3240 // +-------+ +---------+ +---------+
3243 // |---------------->| |
3245 // | RESTSubResp | |
3246 // |<----------------| |
3248 // | |------------->|
3249 // | RESTSubDelReq | |
3250 // |---------------->| |
3251 // | RESTSubDelResp | |
3253 // |<----------------| |
3255 // | |<-------------|
3257 // |<----------------| |
3259 // | [SUBS DELETE] |
3262 //-----------------------------------------------------------------------------
3263 func TestRESTSubReqDelReq(t *testing.T) {
3264 CaseBegin("TestRESTSubReqDelReq")
3266 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3267 Counter{cRestSubReqFromXapp, 1},
3268 Counter{cRestSubRespToXapp, 1},
3269 Counter{cSubReqToE2, 1},
3270 Counter{cSubRespFromE2, 1},
3271 Counter{cRestSubNotifToXapp, 1},
3272 Counter{cRestSubDelReqFromXapp, 2},
3273 Counter{cSubDelReqToE2, 1},
3274 Counter{cSubDelRespFromE2, 1},
3275 Counter{cRestSubDelRespToXapp, 1},
3278 const subReqCount int = 1
3281 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3282 restSubId := xappConn1.SendRESTSubsReq(t, params)
3284 // Del. This will fail as processing of the subscription
3285 // is still ongoing in submgr. Deletion is not allowed before
3286 // subscription creation has been completed.
3287 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3288 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3289 xappConn1.ExpectRESTNotification(t, restSubId)
3290 e2termConn1.SendSubsResp(t, crereq, cremsg)
3291 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3294 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3296 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3297 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3299 // Wait that subs is cleaned
3300 waitSubsCleanup(t, e2SubsId, 10)
3301 mainCtrl.VerifyCounterValues(t)
3305 func TestRESTSubDelReqCollision(t *testing.T) {
3306 CaseBegin("TestRESTSubDelReqCollision - not relevant for REST API")
3309 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
3310 CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel")
3312 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3313 Counter{cRestSubReqFromXapp, 2},
3314 Counter{cRestSubRespToXapp, 2},
3315 Counter{cSubReqToE2, 2},
3316 Counter{cSubRespFromE2, 2},
3317 Counter{cRestSubNotifToXapp, 2},
3318 Counter{cRestSubDelReqFromXapp, 2},
3319 Counter{cSubDelReqToE2, 2},
3320 Counter{cSubDelRespFromE2, 2},
3321 Counter{cRestSubDelRespToXapp, 2},
3325 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3326 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3327 xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3330 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3331 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3332 xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3334 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3335 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3337 //XappConn1 receives both of the responses
3338 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3341 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3343 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3345 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3346 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3347 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3348 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3351 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3353 deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
3355 //Wait that subs is cleaned
3356 mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
3357 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
3359 mainCtrl.VerifyCounterValues(t)
3363 func TestRESTSameSubsDiffRan(t *testing.T) {
3364 CaseBegin("TestRESTSameSubsDiffRan")
3366 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3367 Counter{cRestSubReqFromXapp, 2},
3368 Counter{cRestSubRespToXapp, 2},
3369 Counter{cSubReqToE2, 2},
3370 Counter{cSubRespFromE2, 2},
3371 Counter{cRestSubNotifToXapp, 2},
3372 Counter{cRestSubDelReqFromXapp, 2},
3373 Counter{cSubDelReqToE2, 2},
3374 Counter{cSubDelRespFromE2, 2},
3375 Counter{cRestSubDelRespToXapp, 2},
3378 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3379 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3380 xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3382 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3383 params.SetMeid("RAN_NAME_2")
3384 restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
3385 xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3388 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3390 deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
3392 //Wait that subs is cleaned
3393 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3394 waitSubsCleanup(t, e2SubsId2, 10)
3396 mainCtrl.VerifyCounterValues(t)
3400 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
3401 CaseBegin("TestRESTSubReqRetryInSubmgr start")
3403 // Init counter check
3404 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3405 Counter{cRestSubReqFromXapp, 1},
3406 Counter{cRestSubRespToXapp, 1},
3407 Counter{cSubReqToE2, 1},
3408 Counter{cSubReReqToE2, 1},
3409 Counter{cSubRespFromE2, 1},
3410 Counter{cRestSubNotifToXapp, 1},
3411 Counter{cRestSubDelReqFromXapp, 1},
3412 Counter{cSubDelReqToE2, 1},
3413 Counter{cSubDelRespFromE2, 1},
3414 Counter{cRestSubDelRespToXapp, 1},
3417 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3418 restSubId := xappConn1.SendRESTSubsReq(t, params)
3420 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
3422 // Catch the first message and ignore it
3423 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3424 xapp.Logger.Info("Ignore REST subscriber request for subscriber : %v", restSubId)
3426 // The second request is being handled normally
3427 crereq, cremsg = e2termConn1.RecvSubsReq(t)
3428 xappConn1.ExpectRESTNotification(t, restSubId)
3429 e2termConn1.SendSubsResp(t, crereq, cremsg)
3430 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3432 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3434 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3436 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
3437 //Wait that subs is cleaned
3438 waitSubsCleanup(t, e2SubsId, 10)
3440 mainCtrl.VerifyCounterValues(t)
3444 //-----------------------------------------------------------------------------
3445 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3448 // +-------+ +---------+ +---------+
3449 // | xapp | | submgr | | e2term |
3450 // +-------+ +---------+ +---------+
3453 // |---------------->| |
3455 // | RESTSubResp | |
3456 // |<----------------| |
3458 // | |------------->|
3462 // | |------------->|
3465 // | |------------->|
3469 // | |------------->|
3473 // | |<-------------|
3476 // |<----------------| |
3478 // | [SUBS DELETE] |
3481 //-----------------------------------------------------------------------------
3483 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
3484 CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
3486 // Init counter check
3487 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3488 Counter{cRestSubReqFromXapp, 1},
3489 Counter{cRestSubRespToXapp, 1},
3490 Counter{cSubReqToE2, 1},
3491 Counter{cSubReReqToE2, 1},
3492 Counter{cSubReqTimerExpiry, 2},
3493 Counter{cSubDelReqToE2, 1},
3494 Counter{cSubDelRespFromE2, 1},
3497 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3498 restSubId := xappConn1.SendRESTSubsReq(t, params)
3499 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
3501 e2termConn1.RecvSubsReq(t)
3502 xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3504 e2termConn1.RecvSubsReq(t)
3505 xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3507 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3508 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3509 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3510 xappConn1.WaitRESTNotification(t, restSubId)
3512 // Wait that subs is cleaned
3513 waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
3515 mainCtrl.VerifyCounterValues(t)
3518 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
3519 CaseBegin("TestREST2eTermNotRespondingToSubReq start")
3521 // Init counter check
3522 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3523 Counter{cRestSubReqFromXapp, 1},
3524 Counter{cRestSubRespToXapp, 1},
3525 Counter{cSubReqToE2, 1},
3526 Counter{cSubReReqToE2, 1},
3527 Counter{cSubReqTimerExpiry, 2},
3528 Counter{cSubDelReqToE2, 1},
3529 Counter{cSubDelReqTimerExpiry, 2},
3532 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3533 restSubId := xappConn1.SendRESTSubsReq(t, params)
3534 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
3536 e2termConn1.RecvSubsReq(t)
3537 xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3539 e2termConn1.RecvSubsReq(t)
3540 xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3542 e2termConn1.RecvSubsDelReq(t)
3543 xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3545 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3546 e2termConn1.RecvSubsDelReq(t)
3547 xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3549 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3551 waitSubsCleanup(t, e2SubsId, 10)
3553 mainCtrl.VerifyCounterValues(t)
3557 //-----------------------------------------------------------------------------
3558 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3561 // +-------+ +---------+ +---------+
3562 // | xapp | | submgr | | e2term |
3563 // +-------+ +---------+ +---------+
3566 // |---------------->| |
3568 // | RESTSubResp | |
3569 // |<----------------| |
3571 // | |------------->|
3575 // | |------------->|
3578 // | |------------->|
3582 // | |------------->|
3586 // | |<-------------|
3589 // |<----------------| |
3591 // | [SUBS DELETE] |
3594 //-----------------------------------------------------------------------------
3595 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
3596 CaseBegin("TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr start")
3598 // Init counter check
3599 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3600 Counter{cRestSubReqFromXapp, 1},
3601 Counter{cRestSubRespToXapp, 1},
3602 Counter{cSubReqToE2, 1},
3603 Counter{cSubReReqToE2, 1},
3604 Counter{cSubReqTimerExpiry, 2},
3605 Counter{cSubDelReqToE2, 1},
3606 Counter{cSubDelReReqToE2, 1},
3607 Counter{cSubDelReqTimerExpiry, 2},
3610 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3611 restSubId := xappConn1.SendRESTSubsReq(t, params)
3612 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
3614 e2termConn1.RecvSubsReq(t)
3615 xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3617 e2termConn1.RecvSubsReq(t)
3618 xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3620 e2termConn1.RecvSubsDelReq(t)
3621 xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3623 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3624 e2termConn1.RecvSubsDelReq(t)
3625 xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3627 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3629 waitSubsCleanup(t, e2SubsId, 10)
3631 mainCtrl.VerifyCounterValues(t)
3634 //-----------------------------------------------------------------------------
3635 // TestRESTSubReqSubFailRespInSubmgr
3638 // +-------+ +---------+ +---------+
3639 // | xapp | | submgr | | e2term |
3640 // +-------+ +---------+ +---------+
3643 // |---------------->| |
3645 // | RESTSubResp | |
3646 // |<----------------| |
3648 // | |------------->|
3651 // | |<-------------|
3654 // | |------------->|
3657 // | |<-------------|
3661 // |<----------------| |
3663 // | [SUBS DELETE] |
3666 //-----------------------------------------------------------------------------
3667 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
3668 CaseBegin("TestRESTSubReqSubFailRespInSubmgr")
3670 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3671 Counter{cRestSubReqFromXapp, 1},
3672 Counter{cRestSubRespToXapp, 1},
3673 Counter{cSubReqToE2, 1},
3674 Counter{cSubFailFromE2, 1},
3675 Counter{cRestSubFailNotifToXapp, 1},
3676 Counter{cRestSubDelReqFromXapp, 1},
3679 const subReqCount int = 1
3681 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3682 restSubId := xappConn1.SendRESTSubsReq(t, params)
3684 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3685 fparams1 := &teststube2ap.E2StubSubsFailParams{}
3686 fparams1.Set(crereq1)
3687 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3689 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3690 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3691 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3692 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3693 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
3695 // REST subscription sill there to be deleted
3696 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3698 // Wait that subs is cleaned
3699 waitSubsCleanup(t, e2SubsId, 10)
3701 mainCtrl.VerifyCounterValues(t)
3705 //-----------------------------------------------------------------------------
3706 // TestRESTSubDelReqRetryInSubmgr
3709 // +-------+ +---------+ +---------+
3710 // | xapp | | submgr | | e2term |
3711 // +-------+ +---------+ +---------+
3713 // | [SUBS CREATE] |
3716 // | RESTSubDelReq | |
3717 // |---------------->| |
3719 // | RESTSubDelResp | |
3720 // |<----------------| |
3722 // | |------------->|
3725 // | |------------->|
3728 // | |<-------------|
3731 //-----------------------------------------------------------------------------
3732 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
3733 CaseBegin("TestRESTSubDelReqRetryInSubmgr")
3735 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3736 Counter{cRestSubReqFromXapp, 1},
3737 Counter{cRestSubRespToXapp, 1},
3738 Counter{cSubReqToE2, 1},
3739 Counter{cSubRespFromE2, 1},
3740 Counter{cRestSubNotifToXapp, 1},
3741 Counter{cRestSubDelReqFromXapp, 1},
3742 Counter{cSubDelReqToE2, 1},
3743 Counter{cSubDelReReqToE2, 1},
3744 Counter{cSubDelRespFromE2, 1},
3745 Counter{cRestSubDelRespToXapp, 1},
3748 var params *teststube2ap.RESTSubsReqParams = nil
3749 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3752 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3754 // E2t: Receive 1st SubsDelReq
3755 e2termConn1.RecvSubsDelReq(t)
3757 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
3758 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3759 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3761 //Wait that subs is cleaned
3762 waitSubsCleanup(t, e2SubsId, 10)
3764 mainCtrl.VerifyCounterValues(t)
3767 //-----------------------------------------------------------------------------
3768 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
3771 // +-------+ +---------+ +---------+
3772 // | xapp | | submgr | | e2term |
3773 // +-------+ +---------+ +---------+
3775 // | [SUBS CREATE] |
3778 // | RESTSubDelReq | |
3779 // |---------------->| |
3781 // | RESTSubDelResp | |
3782 // |<----------------| |
3784 // | |------------->|
3787 // | |------------->|
3791 //-----------------------------------------------------------------------------
3792 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
3793 CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr")
3795 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3796 Counter{cRestSubReqFromXapp, 1},
3797 Counter{cRestSubRespToXapp, 1},
3798 Counter{cSubReqToE2, 1},
3799 Counter{cSubRespFromE2, 1},
3800 Counter{cRestSubNotifToXapp, 1},
3801 Counter{cRestSubDelReqFromXapp, 1},
3802 Counter{cSubDelReqToE2, 1},
3803 Counter{cSubDelReReqToE2, 1},
3804 Counter{cSubDelRespFromE2, 1},
3805 Counter{cRestSubDelRespToXapp, 1},
3809 var params *teststube2ap.RESTSubsReqParams = nil
3810 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3813 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3815 // E2t: Receive 1st SubsDelReq
3816 e2termConn1.RecvSubsDelReq(t)
3818 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
3819 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3820 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3822 //Wait that subs is cleaned
3823 waitSubsCleanup(t, e2SubsId, 10)
3825 mainCtrl.VerifyCounterValues(t)
3828 //-----------------------------------------------------------------------------
3829 // TestRESTSubDelReqSubDelFailRespInSubmgr
3832 // +-------+ +---------+ +---------+
3833 // | xapp | | submgr | | e2term |
3834 // +-------+ +---------+ +---------+
3836 // | [SUBS CREATE] |
3839 // | RESTSubDelReq | |
3840 // |---------------->| |
3842 // | RESTSubDelResp | |
3843 // |<----------------| |
3845 // | |------------->|
3848 // | |<-------------|
3851 //-----------------------------------------------------------------------------
3852 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
3853 CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr")
3855 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3856 Counter{cRestSubReqFromXapp, 1},
3857 Counter{cRestSubRespToXapp, 1},
3858 Counter{cSubReqToE2, 1},
3859 Counter{cSubRespFromE2, 1},
3860 Counter{cRestSubNotifToXapp, 1},
3861 Counter{cRestSubDelReqFromXapp, 1},
3862 Counter{cSubDelReqToE2, 1},
3863 Counter{cSubDelFailFromE2, 1},
3864 Counter{cRestSubDelRespToXapp, 1},
3868 var params *teststube2ap.RESTSubsReqParams = nil
3869 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3872 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3874 // E2t: Send receive SubsDelReq and send SubsDelFail
3875 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3876 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
3878 //Wait that subs is cleaned
3879 waitSubsCleanup(t, e2SubsId, 10)
3881 mainCtrl.VerifyCounterValues(t)
3884 //-----------------------------------------------------------------------------
3885 // TestRESTSubReqAndSubDelOkSameAction
3888 // +-------+ +-------+ +---------+ +---------+
3889 // | xapp2 | | xapp1 | | submgr | | e2term |
3890 // +-------+ +-------+ +---------+ +---------+
3892 // | | RESTSubReq1 | |
3893 // | |---------------->| |
3895 // | | RESTSubResp1 | |
3896 // | |<----------------| |
3899 // | | |------------->|
3901 // | | |<-------------|
3902 // | | RESTNotif1 | |
3903 // | |<----------------| |
3905 // | RESTSubReq2 | |
3906 // |------------------------------>| |
3908 // | RESTSubResp2 | |
3909 // |<------------------------------| |
3911 // | | RESTNotif2 | |
3912 // |<------------------------------| |
3914 // | | RESTSubDelReq1 | |
3915 // | |---------------->| |
3917 // | | RESTSubDelResp1 | |
3918 // | |<----------------| |
3920 // | RESTSubDelReq2 | |
3921 // |------------------------------>| |
3923 // | RESTSubDelResp2 | |
3924 // |<------------------------------| |
3926 // | | | SubDelReq2 |
3927 // | | |------------->|
3929 // | | | SubDelResp2 |
3930 // | | |<-------------|
3933 //-----------------------------------------------------------------------------
3934 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
3935 CaseBegin("TestRESTSubReqAndSubDelOkSameAction")
3937 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3938 Counter{cRestSubReqFromXapp, 2},
3939 Counter{cRestSubRespToXapp, 2},
3940 Counter{cSubReqToE2, 1},
3941 Counter{cSubRespFromE2, 1},
3942 Counter{cRestSubNotifToXapp, 2},
3943 Counter{cMergedSubscriptions, 1},
3944 Counter{cUnmergedSubscriptions, 1},
3945 Counter{cRestSubDelReqFromXapp, 2},
3946 Counter{cSubDelReqToE2, 1},
3947 Counter{cSubDelRespFromE2, 1},
3948 Counter{cRestSubDelRespToXapp, 2},
3952 var params *teststube2ap.RESTSubsReqParams = nil
3955 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3956 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
3959 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3960 params.SetMeid("RAN_NAME_1")
3962 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
3963 xappConn2.ExpectAnyNotification(t)
3964 waiter := rtmgrHttp.AllocNextSleep(10, true)
3965 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3966 waiter.WaitResult(t)
3967 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
3968 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
3969 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
3971 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
3974 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3977 deleteXapp2Subscription(t, &restSubId2)
3979 //Wait that subs is cleaned
3980 waitSubsCleanup(t, e2SubsId2, 10)
3982 mainCtrl.VerifyCounterValues(t)
3985 //-----------------------------------------------------------------------------
3986 // TestSubReqAndSubDelOkSameActionParallel
3989 // +-------+ +-------+ +---------+ +---------+
3990 // | xapp2 | | xapp1 | | submgr | | e2term |
3991 // +-------+ +-------+ +---------+ +---------+
3996 // | |------------->| |
3999 // | | |------------->|
4001 // |--------------------------->| |
4003 // | | |<-------------|
4005 // | |<-------------| |
4007 // | | |------------->|
4010 // | | |<-------------|
4012 // |<---------------------------| |
4014 // | | SubDelReq 1 | |
4015 // | |------------->| |
4017 // | | SubDelResp 1 | |
4018 // | |<-------------| |
4020 // | SubDelReq 2 | |
4021 // |--------------------------->| |
4023 // | | | SubDelReq 2 |
4024 // | | |------------->|
4026 // | | | SubDelReq 2 |
4027 // | | |------------->|
4029 // | SubDelResp 2 | |
4030 // |<---------------------------| |
4032 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
4033 CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel")
4035 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4036 Counter{cRestSubReqFromXapp, 2},
4037 Counter{cRestSubRespToXapp, 2},
4038 Counter{cSubReqToE2, 2},
4039 Counter{cSubRespFromE2, 2},
4040 Counter{cRestSubNotifToXapp, 2},
4041 Counter{cRestSubDelReqFromXapp, 2},
4042 Counter{cSubDelReqToE2, 2},
4043 Counter{cSubDelRespFromE2, 2},
4044 Counter{cRestSubDelRespToXapp, 2},
4047 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4048 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4049 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4051 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4052 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4054 xappConn1.ExpectRESTNotification(t, restSubId1)
4055 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4056 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4058 xappConn2.ExpectRESTNotification(t, restSubId2)
4059 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
4060 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
4061 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4064 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4065 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4066 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4067 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4070 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4071 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
4072 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
4074 waitSubsCleanup(t, e2SubsId2, 10)
4076 mainCtrl.VerifyCounterValues(t)
4079 //-----------------------------------------------------------------------------
4080 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
4083 // +-------+ +-------+ +---------+ +---------+
4084 // | xapp2 | | xapp1 | | submgr | | e2term |
4085 // +-------+ +-------+ +---------+ +---------+
4089 // | | RESTSubReq1 | |
4090 // | |---------------->| |
4092 // | | RESTSubResp1 | |
4093 // | |<----------------| |
4095 // | | |------------->|
4096 // | RESTSubReq2 | |
4097 // |------------------------------>| |
4099 // | RESTSubDelResp2 | |
4100 // |<------------------------------| |
4102 // | | |------------->|
4105 // | | | SubDelReq |
4106 // | | |------------->|
4108 // | | | SubDelResp |
4109 // | | |<-------------|
4110 // | | RESTNotif1 | |
4111 // | | unsuccess | |
4112 // | |<----------------| |
4114 // | | unsuccess | |
4115 // |<------------------------------| |
4117 // | | RESTSubDelReq1 | |
4118 // | |---------------->| |
4120 // | | RESTSubDelResp1 | |
4121 // | |<----------------| |
4123 // | RESTSubDelReq2 | |
4124 // |------------------------------>| |
4126 // | RESTSubDelResp2 | |
4127 // |<------------------------------| |
4129 //-----------------------------------------------------------------------------
4130 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
4131 CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
4133 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4134 Counter{cRestSubReqFromXapp, 2},
4135 Counter{cRestSubRespToXapp, 2},
4136 Counter{cSubReqToE2, 1},
4137 Counter{cRestSubFailNotifToXapp, 2},
4138 Counter{cRestSubDelReqFromXapp, 2},
4139 Counter{cSubDelReqToE2, 1},
4140 Counter{cSubDelRespFromE2, 1},
4141 Counter{cRestSubDelRespToXapp, 2},
4144 const subReqCount int = 1
4147 params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4148 restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
4149 crereq1, _ := e2termConn1.RecvSubsReq(t)
4152 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4153 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4154 params2.SetMeid("RAN_NAME_1")
4155 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4156 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4158 //Req1 (retransmitted)
4159 e2termConn1.RecvSubsReq(t)
4161 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4163 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4164 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4166 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4167 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4168 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4169 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4172 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4175 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4177 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
4179 //Wait that subs is cleaned
4180 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4182 mainCtrl.VerifyCounterValues(t)
4185 //-----------------------------------------------------------------------------
4186 // TestRESTSubReqAndSubDelNokSameActionParallel
4189 // +-------+ +-------+ +---------+ +---------+
4190 // | xapp2 | | xapp1 | | submgr | | e2term |
4191 // +-------+ +-------+ +---------+ +---------+
4195 // | | RESTSubReq1 | |
4196 // | |---------------->| |
4198 // | | RESTSubResp1 | |
4199 // | |<----------------| |
4201 // | | |------------->|
4202 // | RESTSubReq2 | |
4203 // |------------------------------>| |
4205 // | RESTSubDelResp2 | |
4206 // |<------------------------------| |
4208 // | | |<-------------|
4210 // | | RESTNotif1 | |
4211 // | | unsuccess | |
4212 // | |<----------------| |
4214 // | | unsuccess | |
4215 // |<------------------------------| |
4216 // | | | SubDelReq |
4217 // | | |------------->|
4218 // | | | SubDelResp |
4219 // | | |<-------------|
4221 // | | RESTSubDelReq1 | |
4222 // | |---------------->| |
4224 // | | RESTSubDelResp1 | |
4225 // | |<----------------| |
4227 // | RESTSubDelReq2 | |
4228 // |------------------------------>| |
4230 // | RESTSubDelResp2 | |
4231 // |<------------------------------| |
4233 //-----------------------------------------------------------------------------
4234 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
4235 CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
4237 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4238 Counter{cRestSubReqFromXapp, 2},
4239 Counter{cRestSubRespToXapp, 2},
4240 Counter{cSubReqToE2, 1},
4241 Counter{cSubFailFromE2, 1},
4242 Counter{cRestSubFailNotifToXapp, 2},
4243 Counter{cRestSubDelReqFromXapp, 2},
4244 Counter{cSubDelReqToE2, 1},
4245 Counter{cSubDelRespFromE2, 1},
4246 Counter{cRestSubDelRespToXapp, 2},
4249 const subReqCount int = 1
4252 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4253 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4254 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4257 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4258 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4259 params2.SetMeid("RAN_NAME_1")
4260 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4261 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4263 // E2t: send SubsFail (first)
4264 fparams1 := &teststube2ap.E2StubSubsFailParams{}
4265 fparams1.Set(crereq1)
4266 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
4268 // E2t: internal delete
4269 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4270 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4271 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4273 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4274 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4275 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4276 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4279 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4282 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4284 //Wait that subs is cleaned
4285 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4286 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
4288 mainCtrl.VerifyCounterValues(t)
4291 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
4292 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4294 // Init counter check
4295 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4296 Counter{cRestSubReqFromXapp, 1},
4297 Counter{cRestSubRespToXapp, 1},
4298 Counter{cSubReqToE2, 1},
4299 Counter{cSubRespFromE2, 1},
4300 Counter{cRestSubNotifToXapp, 1},
4301 Counter{cRestSubDelReqFromXapp, 1},
4302 Counter{cSubDelReqToE2, 1},
4303 Counter{cSubDelRespFromE2, 1},
4304 Counter{cRestSubDelRespToXapp, 1},
4307 const subReqCount int = 1
4309 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4310 restSubId := xappConn1.SendRESTSubsReq(t, params)
4311 xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
4313 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4314 xappConn1.ExpectRESTNotification(t, restSubId)
4315 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4316 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4317 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
4319 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4320 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4321 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4323 // Wait that subs is cleaned
4324 waitSubsCleanup(t, e2SubsId, 10)
4325 mainCtrl.VerifyCounterValues(t)
4328 //-----------------------------------------------------------------------------
4329 // TestRESTSubReqPolicyChangeAndSubDelOk
4332 // +-------+ +---------+ +---------+
4333 // | xapp | | submgr | | e2term |
4334 // +-------+ +---------+ +---------+
4337 // |---------------->| |
4339 // | RESTSubResp | |
4340 // |<----------------| |
4342 // | |------------->|
4345 // | |<-------------|
4348 // |<----------------| |
4351 // |---------------->| |
4353 // | RESTSubResp | |
4354 // |<----------------| |
4356 // | |------------->|
4359 // | |<-------------|
4362 // |<----------------| |
4364 // | RESTSubDelReq | |
4365 // |---------------->| |
4368 // | |------------->|
4371 // | |<-------------|
4373 // | RESTSubDelResp | |
4374 // |<----------------| |
4376 //-----------------------------------------------------------------------------
4377 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
4378 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4380 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4381 Counter{cRestSubReqFromXapp, 2},
4382 Counter{cRestSubRespToXapp, 2},
4383 Counter{cSubReqToE2, 2},
4384 Counter{cSubRespFromE2, 2},
4385 Counter{cRestSubNotifToXapp, 2},
4386 Counter{cRestSubDelReqFromXapp, 1},
4387 Counter{cSubDelReqToE2, 1},
4388 Counter{cSubDelRespFromE2, 1},
4389 Counter{cRestSubDelRespToXapp, 1},
4392 const subReqCount int = 1
4395 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4396 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4399 // GetRESTSubsReqPolicyParams sets some coutners on tc side.
4401 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4402 params.SetSubscriptionID(&restSubId)
4403 params.SetTimeToWait("w200ms")
4404 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
4407 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4409 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4410 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4412 // Wait that subs is cleaned
4413 waitSubsCleanup(t, e2SubsId, 10)
4414 mainCtrl.VerifyCounterValues(t)
4417 //-----------------------------------------------------------------------------
4418 // TestRESTSubReqPolicyChangeNOk
4421 // +-------+ +---------+ +---------+
4422 // | xapp | | submgr | | e2term |
4423 // +-------+ +---------+ +---------+
4426 // |---------------->| |
4428 // | RESTSubResp | |
4429 // |<----------------| |
4431 // | |------------->|
4434 // | |<-------------|
4437 // |<----------------| |
4440 // |---------------->| |
4442 // | RESTSubUpdateFail |
4444 // | RESTSubDelReq | |
4445 // |---------------->| |
4448 // | |------------->|
4451 // | |<-------------|
4453 // | RESTSubDelResp | |
4454 // |<----------------| |
4456 //-----------------------------------------------------------------------------
4457 func TestRESTSubReqPolicyChangeNOk(t *testing.T) {
4458 CaseBegin("TestRESTSubReqPolicyChangeNOk")
4460 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4461 Counter{cRestSubReqFromXapp, 2},
4462 Counter{cRestSubRespToXapp, 1},
4463 Counter{cSubReqToE2, 1},
4464 Counter{cSubRespFromE2, 1},
4465 Counter{cRestSubNotifToXapp, 1},
4466 Counter{cRestSubFailToXapp, 1},
4467 Counter{cRestSubDelReqFromXapp, 1},
4468 Counter{cSubDelReqToE2, 1},
4469 Counter{cSubDelRespFromE2, 1},
4470 Counter{cRestSubDelRespToXapp, 1},
4473 const subReqCount int = 1
4476 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4477 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4481 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4483 restSubIdUpd := strings.ToUpper(restSubId)
4484 params.SetSubscriptionID(&restSubIdUpd)
4485 params.SetTimeToWait("w200ms")
4487 restSubId2 := xappConn1.SendRESTSubsReq(t, params)
4488 assert.Equal(t, restSubId2, "")
4491 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4493 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4494 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4496 // Wait that subs is cleaned
4497 waitSubsCleanup(t, e2SubsId, 10)
4498 mainCtrl.VerifyCounterValues(t)
4501 //-----------------------------------------------------------------------------
4502 // TestRESTSubReqAndSubDelOkTwoE2termParallel
4505 // +-------+ +---------+ +---------+ +---------+
4506 // | xapp | | submgr | | e2term1 | | e2term2 |
4507 // +-------+ +---------+ +---------+ +---------+
4511 // | RESTSubReq1 | | |
4512 // |---------------->| | |
4514 // | RESTSubResp1 | | |
4515 // |<----------------| | |
4517 // | |------------->| |
4519 // | RESTSubReq2 | | |
4520 // |---------------->| | |
4522 // | RESTSubResp2 | | |
4523 // |<----------------| | |
4525 // | |---------------------------->|
4528 // | |<-------------| |
4529 // | RESTNotif1 | | |
4530 // |<----------------| | |
4532 // | |<----------------------------|
4533 // | RESTNotif2 | | |
4534 // |<----------------| | |
4536 // | [SUBS 1 DELETE] | |
4538 // | [SUBS 2 DELETE] | |
4541 //-----------------------------------------------------------------------------
4542 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
4543 CaseBegin("TestRESTSubReqAndSubDelOkTwoE2termParallel")
4545 // Init counter check
4546 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4547 Counter{cRestSubReqFromXapp, 2},
4548 Counter{cRestSubRespToXapp, 2},
4549 Counter{cSubReqToE2, 2},
4550 Counter{cSubRespFromE2, 2},
4551 Counter{cRestSubNotifToXapp, 2},
4552 Counter{cRestSubDelReqFromXapp, 2},
4553 Counter{cSubDelReqToE2, 2},
4554 Counter{cSubDelRespFromE2, 2},
4555 Counter{cRestSubDelRespToXapp, 2},
4558 const subReqCount int = 1
4561 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4562 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4563 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4566 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4567 params.SetMeid("RAN_NAME_11")
4568 // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
4569 // would not work as notification would not be received
4570 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4571 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
4574 xappConn1.ExpectRESTNotification(t, restSubId1)
4575 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4576 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4577 xapp.Logger.Info("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
4580 xappConn2.ExpectRESTNotification(t, restSubId2)
4581 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
4582 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4583 xapp.Logger.Info("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
4586 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4587 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4588 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4590 // Wait that subs is cleaned
4591 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4594 xappConn1.SendRESTSubsDelReq(t, &restSubId2)
4595 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
4596 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
4598 // Wait that subs is cleaned
4599 waitSubsCleanup(t, e2SubsId2, 10)
4601 mainCtrl.VerifyCounterValues(t)
4604 //-----------------------------------------------------------------------------
4605 // TestRESTSubReqAsn1EncodeFail
4607 // In this case submgr send RICSubscriptionDeleteRequest after encode failure which should not happen!
4609 // +-------+ +---------+ +---------+
4610 // | xapp | | submgr | | e2term |
4611 // +-------+ +---------+ +---------+
4614 // |---------------->| |
4616 // | RESTSubResp | |
4617 // |<----------------| |
4618 // | RESTSubDelReq | |
4619 // |---------------->| |
4620 // | RESTSubDelResp | |
4622 // |<----------------| |
4625 //-----------------------------------------------------------------------------
4626 func TestRESTSubReqAsn1EncodeFail(t *testing.T) {
4627 CaseBegin("TestRESTSubReqAsn1EncodeFail")
4629 xapp.Logger.Info("Xapp-frame, v0.8.1 sufficient REST API validation")
4633 //-----------------------------------------------------------------------------
4634 // TestRESTSubReqInsertAndSubDelOk
4637 // +-------+ +---------+ +---------+
4638 // | xapp | | submgr | | e2term |
4639 // +-------+ +---------+ +---------+
4642 // |---------------->| |
4644 // | RESTSubResp | |
4645 // |<----------------| |
4648 // | |------------->|
4651 // | |<-------------|
4653 // |<----------------| |
4656 // | RESTSubDelReq | |
4657 // |---------------->| |
4660 // | |------------->|
4663 // | |<-------------|
4665 // | RESTSubDelResp| |
4666 // |<----------------| |
4668 //-----------------------------------------------------------------------------
4669 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
4670 CaseBegin("TestRESTInsertSubReqAndSubDelOk")
4672 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4673 Counter{cRestSubReqFromXapp, 1},
4674 Counter{cRestSubRespToXapp, 1},
4675 Counter{cSubReqToE2, 1},
4676 Counter{cSubRespFromE2, 1},
4677 Counter{cRestSubNotifToXapp, 1},
4678 Counter{cRestSubDelReqFromXapp, 1},
4679 Counter{cSubDelReqToE2, 1},
4680 Counter{cSubDelRespFromE2, 1},
4681 Counter{cRestSubDelRespToXapp, 1},
4684 const subReqCount int = 1
4686 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4687 params.SetSubActionTypes("insert")
4690 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4693 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4695 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4696 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4698 // Wait that subs is cleaned
4699 waitSubsCleanup(t, e2SubsId, 10)
4700 mainCtrl.VerifyCounterValues(t)
4703 //-----------------------------------------------------------------------------
4704 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
4707 // +-------+ +---------+ +---------+
4708 // | xapp | | submgr | | e2term |
4709 // +-------+ +---------+ +---------+
4712 // |------------->| |
4715 // | |------------->|
4720 // | Submgr restart |
4724 // | |------------->|
4727 // | |<-------------|
4730 //-----------------------------------------------------------------------------
4731 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
4732 CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle")
4734 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4735 Counter{cRestSubReqFromXapp, 1},
4736 Counter{cRestSubRespToXapp, 1},
4737 Counter{cSubReqToE2, 1},
4738 Counter{cSubDelReqFromXapp, 1},
4739 Counter{cSubDelReqToE2, 1},
4740 Counter{cSubDelRespFromE2, 1},
4743 const subReqCount int = 1
4745 // Remove possible existing subscription
4746 mainCtrl.removeExistingSubscriptions(t)
4748 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4751 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
4752 restSubId := xappConn1.SendRESTSubsReq(t, params)
4753 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
4755 e2termConn1.RecvSubsReq(t)
4757 mainCtrl.SetResetTestFlag(t, false)
4759 mainCtrl.SimulateRestart(t)
4760 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4763 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4764 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4766 xappConn1.TestMsgChanEmpty(t)
4767 xappConn2.TestMsgChanEmpty(t)
4768 e2termConn1.TestMsgChanEmpty(t)
4769 mainCtrl.wait_registry_empty(t, 10)
4771 mainCtrl.VerifyCounterValues(t)
4774 //-----------------------------------------------------------------------------
4775 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
4778 // +-------+ +---------+ +---------+
4779 // | xapp | | submgr | | e2term |
4780 // +-------+ +---------+ +---------+
4783 // |---------------->| |
4785 // | RESTSubResp | |
4786 // |<----------------| |
4788 // | |------------->|
4791 // | |<-------------|
4794 // |<----------------| |
4797 // | Submgr restart |
4799 // | RESTSubDelReq | |
4800 // |---------------->| |
4803 // | |------------->|
4806 // | |<-------------|
4808 // | RESTSubDelResp | |
4809 // |<----------------| |
4811 //-----------------------------------------------------------------------------
4813 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
4814 CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle")
4816 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4817 Counter{cRestSubReqFromXapp, 1},
4818 Counter{cRestSubRespToXapp, 1},
4819 Counter{cSubReqToE2, 1},
4820 Counter{cSubRespFromE2, 1},
4821 Counter{cRestSubNotifToXapp, 1},
4822 Counter{cRestSubDelReqFromXapp, 1},
4823 Counter{cSubDelReqToE2, 1},
4824 Counter{cRestSubDelRespToXapp, 1},
4827 // Remove possible existing subscription
4828 mainCtrl.removeExistingSubscriptions(t)
4830 var params *teststube2ap.RESTSubsReqParams = nil
4832 // Create subscription
4833 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4834 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
4836 // Check subscription
4837 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4839 // When SDL support for the REST Interface is added
4840 // the submgr restart statement below should be removed
4841 // from the comment.
4843 // mainCtrl.SimulateRestart(t)
4844 // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4846 // Check subscription
4847 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4849 // Delete subscription
4850 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
4852 //Wait that subs is cleaned
4853 waitSubsCleanup(t, e2SubsId, 10)
4855 mainCtrl.VerifyCounterValues(t)
4858 //-----------------------------------------------------------------------------
4859 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
4862 // +-------+ +-------+ +---------+ +---------+
4863 // | xapp2 | | xapp1 | | submgr | | e2term |
4864 // +-------+ +-------+ +---------+ +---------+
4866 // | | RESTSubReq1 | |
4867 // | |---------------->| |
4869 // | | RESTSubResp1 | |
4870 // | |<----------------| |
4873 // | | |------------->|
4875 // | | |<-------------|
4876 // | | RESTNotif1 | |
4877 // | |<----------------| |
4879 // | RESTSubReq2 | |
4880 // |------------------------------>| |
4882 // | RESTSubResp2 | |
4883 // |<------------------------------| |
4885 // | | RESTNotif2 | |
4886 // |<------------------------------| |
4888 // | | Submgr restart |
4890 // | | RESTSubDelReq1 | |
4891 // | |---------------->| |
4893 // | | RESTSubDelResp1 | |
4894 // | |<----------------| |
4896 // | | Submgr restart |
4898 // | RESTSubDelReq2 | |
4899 // |------------------------------>| |
4901 // | RESTSubDelResp2 | |
4902 // |<------------------------------| |
4904 // | | | SubDelReq2 |
4905 // | | |------------->|
4907 // | | | SubDelResp2 |
4908 // | | |<-------------|
4911 //-----------------------------------------------------------------------------
4913 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
4914 CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
4916 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4917 Counter{cRestSubReqFromXapp, 2},
4918 Counter{cRestSubRespToXapp, 2},
4919 Counter{cSubReqToE2, 1},
4920 Counter{cSubRespFromE2, 1},
4921 Counter{cRestSubNotifToXapp, 2},
4922 Counter{cMergedSubscriptions, 1},
4923 Counter{cUnmergedSubscriptions, 1},
4924 Counter{cRestSubDelReqFromXapp, 2},
4925 Counter{cSubDelReqToE2, 1},
4926 Counter{cSubDelRespFromE2, 1},
4927 Counter{cRestSubDelRespToXapp, 2},
4930 // Remove possible existing subscription
4931 mainCtrl.removeExistingSubscriptions(t)
4933 var params *teststube2ap.RESTSubsReqParams = nil
4935 // Create subscription 1
4936 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4937 xapp.Logger.Info("Send REST subscriber request for subscriber 1 : %v", restSubId1)
4939 // Create subscription 2 with same action
4940 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4941 params.SetMeid("RAN_NAME_1")
4942 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4943 xappConn2.ExpectAnyNotification(t)
4944 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4945 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4946 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
4947 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
4949 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
4951 // When SDL support for the REST Interface is added
4952 // the submgr restart statement below should be removed
4953 // from the comment.
4955 // mainCtrl.SimulateRestart(t)
4956 // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4958 // Delete subscription 1, and wait until it has removed the first endpoint
4959 subepcnt := mainCtrl.get_subs_entrypoint_cnt(t, e2SubsId1)
4960 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4961 mainCtrl.wait_subs_entrypoint_cnt_change(t, e2SubsId1, subepcnt, 10)
4963 // When SDL support for the REST Interface is added
4964 // the submgr restart statement below should be removed
4965 // from the comment.
4967 // mainCtrl.SimulateRestart(t)
4968 // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4969 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
4971 // Delete subscription 2
4972 deleteXapp2Subscription(t, &restSubId2)
4974 //Wait that subs is cleaned
4975 waitSubsCleanup(t, e2SubsId2, 10)
4977 mainCtrl.VerifyCounterValues(t)
4980 //-----------------------------------------------------------------------------
4981 // TestRESTReportSubReqAndSubDelOk
4984 // +-------+ +---------+ +---------+
4985 // | xapp | | submgr | | e2term |
4986 // +-------+ +---------+ +---------+
4989 // |---------------->| |
4991 // | RESTSubResp | |
4992 // |<----------------| |
4995 // | |------------->|
4998 // | |<-------------|
5000 // |<----------------| |
5002 // | |------------->|
5005 // | |<-------------|
5007 // |<----------------| |
5011 // | RESTSubDelReq | |
5012 // |---------------->| |
5015 // | |------------->|
5018 // | |<-------------|
5020 // | RESTSubDelResp| |
5021 // |<----------------| |
5023 //-----------------------------------------------------------------------------
5025 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
5026 CaseBegin("TestRESTReportSubReqAndSubDelOk")
5029 RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
5032 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5033 xapp.Logger.Info("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
5036 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5037 restSubId := xappConn1.SendRESTSubsReq(t, params)
5039 var e2SubsId []uint32
5040 for i := 0; i < subReqCount; i++ {
5041 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5042 xappConn1.ExpectRESTNotification(t, restSubId)
5044 e2termConn1.SendSubsResp(t, crereq, cremsg)
5045 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5046 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5047 e2SubsId = append(e2SubsId, instanceId)
5048 resp, _ := xapp.Subscription.QuerySubscriptions()
5049 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
5050 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
5051 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
5056 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5058 for i := 0; i < subReqCount; i++ {
5059 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5060 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5063 // Wait that subs is cleaned
5064 for i := 0; i < subReqCount; i++ {
5065 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5068 xappConn1.TestMsgChanEmpty(t)
5069 e2termConn1.TestMsgChanEmpty(t)
5070 mainCtrl.wait_registry_empty(t, 10)
5074 func TestRESTPolicySubReqAndSubDelOk(t *testing.T) {
5075 CaseBegin("TestRESTPolicySubReqAndSubDelOk")
5079 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5083 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5086 func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5087 xapp.Logger.Info("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
5090 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5091 restSubId := xappConn1.SendRESTSubsReq(t, params)
5092 //params := xappConn1.GetRESTSubsReqPolicyParams1(subReqCount)
5093 //restSubId := xappConn1.SendRESTPolicySubsReq(t, params)
5095 var e2SubsId []uint32
5096 for i := 0; i < subReqCount; i++ {
5097 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5098 xappConn1.ExpectRESTNotification(t, restSubId)
5099 e2termConn1.SendSubsResp(t, crereq, cremsg)
5100 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5101 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5102 e2SubsId = append(e2SubsId, instanceId)
5106 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5108 for i := 0; i < subReqCount; i++ {
5109 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5110 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5113 // Wait that subs is cleaned
5114 for i := 0; i < subReqCount; i++ {
5115 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5117 xappConn1.TestMsgChanEmpty(t)
5118 e2termConn1.TestMsgChanEmpty(t)
5119 mainCtrl.wait_registry_empty(t, 10)
5122 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
5126 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5127 Counter{cRestSubReqFromXapp, 1},
5128 Counter{cRestSubRespToXapp, 1},
5129 Counter{cSubReqToE2, 2},
5130 Counter{cSubRespFromE2, 2},
5131 Counter{cRestSubNotifToXapp, 2},
5132 Counter{cRestSubDelReqFromXapp, 1},
5133 Counter{cSubDelReqToE2, 2},
5134 Counter{cSubDelRespFromE2, 2},
5135 Counter{cRestSubDelRespToXapp, 1},
5139 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5140 restSubId := xappConn1.SendRESTSubsReq(t, params)
5141 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5143 assert.Equal(t, len(e2SubsIds), 2)
5146 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5147 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5149 xappConn1.TestMsgChanEmpty(t)
5150 e2termConn1.TestMsgChanEmpty(t)
5151 mainCtrl.wait_registry_empty(t, 10)
5153 mainCtrl.VerifyCounterValues(t)
5155 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
5159 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5160 Counter{cRestSubReqFromXapp, 1},
5161 Counter{cRestSubRespToXapp, 1},
5162 Counter{cSubReqToE2, 19},
5163 Counter{cSubRespFromE2, 19},
5164 Counter{cRestSubNotifToXapp, 19},
5165 Counter{cRestSubDelReqFromXapp, 1},
5166 Counter{cSubDelReqToE2, 19},
5167 Counter{cSubDelRespFromE2, 19},
5168 Counter{cRestSubDelRespToXapp, 1},
5172 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5173 restSubId := xappConn1.SendRESTSubsReq(t, params)
5174 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5176 assert.Equal(t, len(e2SubsIds), 19)
5178 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5179 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5181 xappConn1.TestMsgChanEmpty(t)
5182 e2termConn1.TestMsgChanEmpty(t)
5183 mainCtrl.wait_registry_empty(t, 10)
5185 mainCtrl.VerifyCounterValues(t)
5187 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
5191 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5192 Counter{cRestSubReqFromXapp, 1},
5193 Counter{cRestSubRespToXapp, 1},
5194 Counter{cSubReqToE2, uint64(subReqCount)},
5195 Counter{cSubRespFromE2, uint64(subReqCount)},
5196 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5197 Counter{cRestSubDelReqFromXapp, 1},
5198 Counter{cSubDelReqToE2, uint64(subReqCount)},
5199 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5200 Counter{cRestSubDelRespToXapp, 1},
5204 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5205 restSubId := xappConn1.SendRESTSubsReq(t, params)
5206 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5208 assert.Equal(t, len(e2SubsIds), subReqCount)
5211 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5212 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5214 xappConn1.TestMsgChanEmpty(t)
5215 e2termConn1.TestMsgChanEmpty(t)
5216 mainCtrl.wait_registry_empty(t, 10)
5218 mainCtrl.VerifyCounterValues(t)
5221 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
5225 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5226 Counter{cRestSubReqFromXapp, 1},
5227 Counter{cRestSubRespToXapp, 1},
5228 Counter{cSubReqToE2, uint64(subReqCount)},
5229 Counter{cSubRespFromE2, uint64(subReqCount)},
5230 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5231 Counter{cRestSubDelReqFromXapp, 1},
5232 Counter{cSubDelReqToE2, uint64(subReqCount)},
5233 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5234 Counter{cRestSubDelRespToXapp, 1},
5238 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5239 restSubId := xappConn1.SendRESTSubsReq(t, params)
5240 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5242 assert.Equal(t, len(e2SubsIds), subReqCount)
5245 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5246 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5248 xappConn1.TestMsgChanEmpty(t)
5249 e2termConn1.TestMsgChanEmpty(t)
5250 mainCtrl.wait_registry_empty(t, 10)
5252 mainCtrl.VerifyCounterValues(t)
5255 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
5259 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5260 Counter{cRestSubReqFromXapp, 1},
5261 Counter{cRestSubRespToXapp, 1},
5262 Counter{cSubReqToE2, uint64(subReqCount)},
5263 Counter{cSubRespFromE2, uint64(subReqCount)},
5264 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5265 Counter{cRestSubDelReqFromXapp, 1},
5266 Counter{cSubDelReqToE2, uint64(subReqCount)},
5267 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5268 Counter{cRestSubDelRespToXapp, 1},
5272 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5273 restSubId := xappConn1.SendRESTSubsReq(t, params)
5274 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5276 assert.Equal(t, len(e2SubsIds), subReqCount)
5279 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5280 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5282 xappConn1.TestMsgChanEmpty(t)
5283 e2termConn1.TestMsgChanEmpty(t)
5284 mainCtrl.wait_registry_empty(t, 10)
5286 mainCtrl.VerifyCounterValues(t)
5289 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
5290 CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
5292 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5293 Counter{cRestSubReqFromXapp, 2},
5294 Counter{cRestSubRespToXapp, 2},
5295 Counter{cSubReqToE2, 2},
5296 Counter{cSubRespFromE2, 2},
5297 Counter{cRestSubNotifToXapp, 2},
5298 Counter{cRestSubDelReqFromXapp, 2},
5299 Counter{cSubDelReqToE2, 2},
5300 Counter{cSubDelRespFromE2, 2},
5301 Counter{cRestSubDelRespToXapp, 2},
5305 var params *teststube2ap.RESTSubsReqParams = nil
5308 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5309 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5311 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5314 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5315 params.SetMeid("RAN_NAME_1")
5316 eventTriggerDefinition := []int64{1234, 1}
5317 params.SetSubEventTriggerDefinition(eventTriggerDefinition)
5319 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5320 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5321 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5322 xappConn2.ExpectRESTNotification(t, restSubId2)
5323 e2termConn1.SendSubsResp(t, crereq, cremsg)
5324 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5326 deleteXapp1Subscription(t, &restSubId1)
5327 deleteXapp2Subscription(t, &restSubId2)
5329 waitSubsCleanup(t, e2SubsId1, 10)
5330 waitSubsCleanup(t, e2SubsId2, 10)
5332 mainCtrl.VerifyCounterValues(t)
5336 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
5337 CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
5339 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5340 Counter{cRestSubReqFromXapp, 2},
5341 Counter{cRestSubRespToXapp, 2},
5342 Counter{cSubReqToE2, 2},
5343 Counter{cSubRespFromE2, 2},
5344 Counter{cRestSubNotifToXapp, 2},
5345 Counter{cRestSubDelReqFromXapp, 2},
5346 Counter{cSubDelReqToE2, 2},
5347 Counter{cSubDelRespFromE2, 2},
5348 Counter{cRestSubDelRespToXapp, 2},
5352 var params *teststube2ap.RESTSubsReqParams = nil
5355 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5356 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5358 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5361 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5362 params.SetMeid("RAN_NAME_1")
5364 actionId := int64(1)
5365 actionType := "report"
5366 actionDefinition := []int64{5678, 1}
5367 subsequestActionType := "continue"
5368 timeToWait := "w10ms"
5369 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
5371 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5372 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5373 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5374 xappConn2.ExpectRESTNotification(t, restSubId2)
5375 e2termConn1.SendSubsResp(t, crereq, cremsg)
5376 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5378 deleteXapp1Subscription(t, &restSubId1)
5379 deleteXapp2Subscription(t, &restSubId2)
5381 waitSubsCleanup(t, e2SubsId1, 10)
5382 waitSubsCleanup(t, e2SubsId2, 10)
5384 mainCtrl.VerifyCounterValues(t)
5388 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
5389 CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
5391 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5392 Counter{cRestSubReqFromXapp, 2},
5393 Counter{cRestSubRespToXapp, 2},
5394 Counter{cSubReqToE2, 2},
5395 Counter{cSubRespFromE2, 2},
5396 Counter{cRestSubNotifToXapp, 2},
5397 Counter{cRestSubDelReqFromXapp, 2},
5398 Counter{cSubDelReqToE2, 2},
5399 Counter{cSubDelRespFromE2, 2},
5400 Counter{cRestSubDelRespToXapp, 2},
5404 var params *teststube2ap.RESTSubsReqParams = nil
5407 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5408 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5410 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5413 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5414 params.SetMeid("RAN_NAME_1")
5415 params.SetSubActionIDs(int64(2))
5417 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5418 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5419 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5420 xappConn2.ExpectRESTNotification(t, restSubId2)
5421 e2termConn1.SendSubsResp(t, crereq, cremsg)
5422 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5424 deleteXapp1Subscription(t, &restSubId1)
5425 deleteXapp2Subscription(t, &restSubId2)
5427 waitSubsCleanup(t, e2SubsId1, 10)
5428 waitSubsCleanup(t, e2SubsId2, 10)
5430 mainCtrl.VerifyCounterValues(t)
5434 func TestRESTSubReqDiffActionType(t *testing.T) {
5435 CaseBegin("TestRESTSubReqDiffActionType")
5437 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5438 Counter{cRestSubReqFromXapp, 2},
5439 Counter{cRestSubRespToXapp, 2},
5440 Counter{cSubReqToE2, 2},
5441 Counter{cSubRespFromE2, 2},
5442 Counter{cRestSubNotifToXapp, 2},
5443 Counter{cRestSubDelReqFromXapp, 2},
5444 Counter{cSubDelReqToE2, 2},
5445 Counter{cSubDelRespFromE2, 2},
5446 Counter{cRestSubDelRespToXapp, 2},
5450 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5453 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5454 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5456 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5459 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5460 params.SetMeid("RAN_NAME_1")
5462 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5463 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5464 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5465 xappConn2.ExpectRESTNotification(t, restSubId2)
5466 e2termConn1.SendSubsResp(t, crereq, cremsg)
5467 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5469 deleteXapp1Subscription(t, &restSubId1)
5470 deleteXapp2Subscription(t, &restSubId2)
5472 waitSubsCleanup(t, e2SubsId1, 10)
5473 waitSubsCleanup(t, e2SubsId2, 10)
5475 mainCtrl.VerifyCounterValues(t)
5479 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
5480 CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
5482 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5483 Counter{cRestSubReqFromXapp, 2},
5484 Counter{cRestSubRespToXapp, 2},
5485 Counter{cSubReqToE2, 2},
5486 Counter{cSubRespFromE2, 2},
5487 Counter{cRestSubNotifToXapp, 2},
5488 Counter{cRestSubDelReqFromXapp, 2},
5489 Counter{cSubDelReqToE2, 2},
5490 Counter{cSubDelRespFromE2, 2},
5491 Counter{cRestSubDelRespToXapp, 2},
5495 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5498 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5499 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5501 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5504 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
5505 params.SetMeid("RAN_NAME_1")
5507 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5508 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5509 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5510 xappConn2.ExpectRESTNotification(t, restSubId2)
5511 e2termConn1.SendSubsResp(t, crereq, cremsg)
5512 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5514 deleteXapp1Subscription(t, &restSubId1)
5515 deleteXapp2Subscription(t, &restSubId2)
5517 waitSubsCleanup(t, e2SubsId1, 10)
5518 waitSubsCleanup(t, e2SubsId2, 10)
5520 mainCtrl.VerifyCounterValues(t)
5524 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
5525 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
5527 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5528 Counter{cRestSubReqFromXapp, 2},
5529 Counter{cRestSubRespToXapp, 2},
5530 Counter{cSubReqToE2, 2},
5531 Counter{cSubRespFromE2, 2},
5532 Counter{cRestSubNotifToXapp, 2},
5533 Counter{cRestSubDelReqFromXapp, 2},
5534 Counter{cSubDelReqToE2, 2},
5535 Counter{cSubDelRespFromE2, 2},
5536 Counter{cRestSubDelRespToXapp, 2},
5540 var params *teststube2ap.RESTSubsReqParams = nil
5543 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5544 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5546 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5549 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5550 params.SetMeid("RAN_NAME_1")
5551 actionDefinition := []int64{5678, 1}
5552 params.SetSubActionDefinition(actionDefinition)
5554 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5555 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5556 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5557 xappConn2.ExpectRESTNotification(t, restSubId2)
5558 e2termConn1.SendSubsResp(t, crereq, cremsg)
5559 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5561 deleteXapp1Subscription(t, &restSubId1)
5562 deleteXapp2Subscription(t, &restSubId2)
5564 waitSubsCleanup(t, e2SubsId1, 10)
5565 waitSubsCleanup(t, e2SubsId2, 10)
5567 mainCtrl.VerifyCounterValues(t)
5571 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
5572 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
5574 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5575 Counter{cRestSubReqFromXapp, 2},
5576 Counter{cRestSubRespToXapp, 2},
5577 Counter{cSubReqToE2, 2},
5578 Counter{cSubRespFromE2, 2},
5579 Counter{cRestSubNotifToXapp, 2},
5580 Counter{cRestSubDelReqFromXapp, 2},
5581 Counter{cSubDelReqToE2, 2},
5582 Counter{cSubDelRespFromE2, 2},
5583 Counter{cRestSubDelRespToXapp, 2},
5587 var params *teststube2ap.RESTSubsReqParams = nil
5590 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5591 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5593 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5596 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5597 params.SetMeid("RAN_NAME_1")
5598 actionDefinition := []int64{56782}
5599 params.SetSubActionDefinition(actionDefinition)
5601 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5602 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5603 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5604 xappConn2.ExpectRESTNotification(t, restSubId2)
5605 e2termConn1.SendSubsResp(t, crereq, cremsg)
5606 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5608 deleteXapp1Subscription(t, &restSubId1)
5609 deleteXapp2Subscription(t, &restSubId2)
5611 waitSubsCleanup(t, e2SubsId1, 10)
5612 waitSubsCleanup(t, e2SubsId2, 10)
5614 mainCtrl.VerifyCounterValues(t)
5618 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
5619 CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
5621 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5622 Counter{cRestSubReqFromXapp, 2},
5623 Counter{cRestSubRespToXapp, 2},
5624 Counter{cSubReqToE2, 2},
5625 Counter{cSubRespFromE2, 2},
5626 Counter{cRestSubNotifToXapp, 2},
5627 Counter{cRestSubDelReqFromXapp, 2},
5628 Counter{cSubDelReqToE2, 2},
5629 Counter{cSubDelRespFromE2, 2},
5630 Counter{cRestSubDelRespToXapp, 2},
5634 var params *teststube2ap.RESTSubsReqParams = nil
5637 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5638 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5640 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5643 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5644 params.SetMeid("RAN_NAME_1")
5645 params.SetTimeToWait("w200ms")
5646 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5647 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5648 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5649 xappConn2.ExpectRESTNotification(t, restSubId2)
5650 e2termConn1.SendSubsResp(t, crereq, cremsg)
5651 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5653 deleteXapp1Subscription(t, &restSubId1)
5654 deleteXapp2Subscription(t, &restSubId2)
5656 waitSubsCleanup(t, e2SubsId1, 10)
5657 waitSubsCleanup(t, e2SubsId2, 10)
5659 mainCtrl.VerifyCounterValues(t)
5663 //-----------------------------------------------------------------------------
5664 // TestRESTUnpackSubscriptionResponseDecodeFail
5667 // +-------+ +---------+ +---------+
5668 // | xapp | | submgr | | e2term |
5669 // +-------+ +---------+ +---------+
5672 // |---------------->| |
5674 // | RESTSubResp | |
5675 // |<----------------| |
5678 // | |------------->|
5680 // | | SubResp | ASN.1 decode fails
5681 // | |<-------------|
5684 // | |------------->|
5686 // | | SubFail | Duplicated action
5687 // | |<-------------|
5688 // | RESTNotif (fail)| |
5689 // |<----------------| |
5691 // | |------------->|
5694 // | |<-------------|
5696 //-----------------------------------------------------------------------------
5698 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
5699 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
5703 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5704 restSubId := xappConn1.SendRESTSubsReq(t, params)
5706 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5707 // Decode of this response fails which will result resending original request
5708 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
5710 _, cremsg = e2termConn1.RecvSubsReq(t)
5712 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
5714 // Subscription already created in E2 Node.
5715 fparams := &teststube2ap.E2StubSubsFailParams{}
5717 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5718 e2termConn1.SendSubsFail(t, fparams, cremsg)
5720 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5721 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5723 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5724 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5726 // Wait that subs is cleaned
5727 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5729 xappConn1.TestMsgChanEmpty(t)
5730 e2termConn1.TestMsgChanEmpty(t)
5731 mainCtrl.wait_registry_empty(t, 10)
5734 //-----------------------------------------------------------------------------
5735 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
5738 // +-------+ +---------+ +---------+
5739 // | xapp | | submgr | | e2term |
5740 // +-------+ +---------+ +---------+
5743 // |---------------->| |
5745 // | RESTSubResp | |
5746 // |<----------------| |
5749 // | |------------->|
5751 // | | SubResp | Unknown instanceId
5752 // | |<-------------|
5755 // | |------------->|
5757 // | | SubFail | Duplicated action
5758 // | |<-------------|
5759 // | RESTNotif (fail)| |
5760 // |<----------------| |
5762 // | |------------->|
5765 // | |<-------------|
5767 //-----------------------------------------------------------------------------
5769 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
5770 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
5774 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5775 restSubId := xappConn1.SendRESTSubsReq(t, params)
5777 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5779 // Unknown instanceId in this response which will result resending original request
5780 orgInstanceId := crereq.RequestId.InstanceId
5781 crereq.RequestId.InstanceId = 0
5782 e2termConn1.SendSubsResp(t, crereq, cremsg)
5784 _, cremsg = e2termConn1.RecvSubsReq(t)
5786 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
5788 // Subscription already created in E2 Node.
5789 fparams := &teststube2ap.E2StubSubsFailParams{}
5791 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5792 e2termConn1.SendSubsFail(t, fparams, cremsg)
5794 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5795 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5797 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5798 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5800 // Wait that subs is cleaned
5801 mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
5803 xappConn1.TestMsgChanEmpty(t)
5804 e2termConn1.TestMsgChanEmpty(t)
5805 mainCtrl.wait_registry_empty(t, 10)
5808 //-----------------------------------------------------------------------------
5809 // TestRESTUnpackSubscriptionResponseNoTransaction
5812 // +-------+ +---------+ +---------+
5813 // | xapp | | submgr | | e2term |
5814 // +-------+ +---------+ +---------+
5817 // |---------------->| |
5819 // | RESTSubResp | |
5820 // |<----------------| |
5823 // | |------------->|
5825 // | | SubResp | No transaction for the response
5826 // | |<-------------|
5829 // | |------------->|
5831 // | | SubFail | Duplicated action
5832 // | |<-------------|
5833 // | RESTNotif (fail)| |
5834 // |<----------------| |
5836 // | |------------->|
5839 // | |<-------------|
5842 // | |------------->|
5845 // | |<-------------|
5847 //-----------------------------------------------------------------------------
5848 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
5849 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
5853 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5854 restSubId := xappConn1.SendRESTSubsReq(t, params)
5856 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5858 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
5859 // No transaction exist for this response which will result resending original request
5860 e2termConn1.SendSubsResp(t, crereq, cremsg)
5862 _, cremsg = e2termConn1.RecvSubsReq(t)
5864 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
5866 // Subscription already created in E2 Node.
5867 fparams := &teststube2ap.E2StubSubsFailParams{}
5869 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5870 e2termConn1.SendSubsFail(t, fparams, cremsg)
5872 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5873 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5875 // Resending happens because there no transaction
5876 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5877 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5879 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5880 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5882 // Wait that subs is cleaned
5883 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5885 xappConn1.TestMsgChanEmpty(t)
5886 e2termConn1.TestMsgChanEmpty(t)
5887 mainCtrl.wait_registry_empty(t, 10)
5891 //-----------------------------------------------------------------------------
5892 // TestRESTUnpackSubscriptionFailureDecodeFail
5895 // +-------+ +---------+ +---------+
5896 // | xapp | | submgr | | e2term |
5897 // +-------+ +---------+ +---------+
5900 // |---------------->| |
5902 // | RESTSubResp | |
5903 // |<----------------| |
5906 // | |------------->|
5908 // | | SubFail | ASN.1 decode fails
5909 // | |<-------------|
5912 // | |------------->|
5914 // | | SubFail | Duplicated action
5915 // | |<-------------|
5916 // | RESTNotif (fail)| |
5917 // |<----------------| |
5919 // | |------------->|
5922 // | |<-------------|
5924 //-----------------------------------------------------------------------------
5925 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
5926 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
5930 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5931 restSubId := xappConn1.SendRESTSubsReq(t, params)
5933 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5935 // Decode of this response fails which will result resending original request
5936 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
5938 _, cremsg = e2termConn1.RecvSubsReq(t)
5940 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
5942 // Subscription already created in E2 Node.
5943 fparams := &teststube2ap.E2StubSubsFailParams{}
5945 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5946 e2termConn1.SendSubsFail(t, fparams, cremsg)
5948 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5949 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5951 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5952 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5954 // Wait that subs is cleaned
5955 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5957 xappConn1.TestMsgChanEmpty(t)
5958 e2termConn1.TestMsgChanEmpty(t)
5959 mainCtrl.wait_registry_empty(t, 10)
5962 //-----------------------------------------------------------------------------
5963 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
5966 // +-------+ +---------+ +---------+
5967 // | xapp | | submgr | | e2term |
5968 // +-------+ +---------+ +---------+
5971 // |---------------->| |
5973 // | RESTSubResp | |
5974 // |<----------------| |
5977 // | |------------->|
5979 // | | SubFail | Unknown instanceId
5980 // | |<-------------|
5983 // | |------------->|
5985 // | | SubFail | Duplicated action
5986 // | |<-------------|
5987 // | RESTNotif (fail)| |
5988 // |<----------------| |
5990 // | |------------->|
5993 // | |<-------------|
5995 //-----------------------------------------------------------------------------
5996 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
5997 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
6001 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6002 restSubId := xappConn1.SendRESTSubsReq(t, params)
6004 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6006 // Unknown instanceId in this response which will result resending original request
6007 fparams := &teststube2ap.E2StubSubsFailParams{}
6009 fparams.Fail.RequestId.InstanceId = 0
6010 e2termConn1.SendSubsFail(t, fparams, cremsg)
6012 _, cremsg = e2termConn1.RecvSubsReq(t)
6014 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6016 // Subscription already created in E2 Node.
6017 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6018 e2termConn1.SendSubsFail(t, fparams, cremsg)
6020 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6021 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6023 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6024 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
6026 // Wait that subs is cleaned
6027 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6029 xappConn1.TestMsgChanEmpty(t)
6030 e2termConn1.TestMsgChanEmpty(t)
6031 mainCtrl.wait_registry_empty(t, 10)
6034 //-----------------------------------------------------------------------------
6035 // TestRESTUnpackSubscriptionFailureNoTransaction
6038 // +-------+ +---------+ +---------+
6039 // | xapp | | submgr | | e2term |
6040 // +-------+ +---------+ +---------+
6043 // |---------------->| |
6045 // | RESTSubResp | |
6046 // |<----------------| |
6049 // | |------------->|
6051 // | | SubFail | No transaction for the response
6052 // | |<-------------|
6055 // | |------------->|
6057 // | | SubFail | Duplicated action
6058 // | |<-------------|
6059 // | RESTNotif (fail)| |
6060 // |<----------------| |
6062 // | |------------->|
6065 // | |<-------------|
6067 //-----------------------------------------------------------------------------
6068 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
6069 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
6073 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6074 restSubId := xappConn1.SendRESTSubsReq(t, params)
6076 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6078 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6080 // No transaction exist for this response which will result resending original request
6081 fparams := &teststube2ap.E2StubSubsFailParams{}
6083 e2termConn1.SendSubsFail(t, fparams, cremsg)
6085 _, cremsg = e2termConn1.RecvSubsReq(t)
6087 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6089 // Subscription already created in E2 Node.
6090 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6091 e2termConn1.SendSubsFail(t, fparams, cremsg)
6093 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6094 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6096 // Resending happens because there no transaction
6097 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6098 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6100 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6101 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
6103 // Wait that subs is cleaned
6104 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6106 xappConn1.TestMsgChanEmpty(t)
6107 e2termConn1.TestMsgChanEmpty(t)
6108 mainCtrl.wait_registry_empty(t, 10)
6111 //-----------------------------------------------------------------------------
6112 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
6115 // +-------+ +---------+ +---------+
6116 // | xapp | | submgr | | e2term |
6117 // +-------+ +---------+ +---------+
6119 // | [SUBS CREATE] |
6122 // | RESTSubDelReq | |
6123 // |---------------->| |
6125 // | RESTSubDelResp | |
6126 // |<----------------| |
6129 // | |------------->|
6131 // | | SubDelResp | ASN.1 decode fails
6132 // | |<-------------|
6135 // | |------------->|
6137 // | | SubDelFail | Subscription does exist any more
6138 // | |<-------------|
6141 //-----------------------------------------------------------------------------
6142 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
6143 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail")
6146 var params *teststube2ap.RESTSubsReqParams = nil
6147 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6150 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6152 // E2t: Receive 1st SubsDelReq
6153 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6155 // Decode of this response fails which will result resending original request
6156 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_REQ)
6158 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6159 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6161 // Subscription does not exist in in E2 Node.
6162 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6164 // Wait that subs is cleaned
6165 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6167 xappConn1.TestMsgChanEmpty(t)
6168 e2termConn1.TestMsgChanEmpty(t)
6169 mainCtrl.wait_registry_empty(t, 10)
6172 //-----------------------------------------------------------------------------
6173 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
6176 // +-------+ +---------+ +---------+
6177 // | xapp | | submgr | | e2term |
6178 // +-------+ +---------+ +---------+
6180 // | [SUBS CREATE] |
6183 // | RESTSubDelReq | |
6184 // |---------------->| |
6186 // | RESTSubDelResp | |
6187 // |<----------------| |
6190 // | |------------->|
6192 // | | SubDelResp | Unknown instanceId
6193 // | |<-------------|
6196 // | |------------->|
6198 // | | SubDelFail | Subscription does exist any more
6199 // | |<-------------|
6201 //-----------------------------------------------------------------------------
6202 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
6203 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId")
6206 var params *teststube2ap.RESTSubsReqParams = nil
6207 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6210 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6212 // E2t: Receive 1st SubsDelReq
6213 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6215 // Unknown instanceId in this response which will result resending original request
6216 delreq.RequestId.InstanceId = 0
6217 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6219 // E2t: Receive 2nd SubsDelReq
6220 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6222 // Subscription does not exist in in E2 Node.
6223 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6225 // Wait that subs is cleaned
6226 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6228 xappConn1.TestMsgChanEmpty(t)
6229 e2termConn1.TestMsgChanEmpty(t)
6230 mainCtrl.wait_registry_empty(t, 10)
6233 //-----------------------------------------------------------------------------
6234 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
6237 // +-------+ +---------+ +---------+
6238 // | xapp | | submgr | | e2term |
6239 // +-------+ +---------+ +---------+
6241 // | [SUBS CREATE] |
6244 // | RESTSubDelReq | |
6245 // |---------------->| |
6247 // | RESTSubDelResp | |
6248 // |<----------------| |
6251 // | |------------->|
6253 // | | SubDelResp | No transaction for the response
6254 // | |<-------------|
6257 // | |------------->|
6259 // | | SubDelFail | Subscription does exist any more
6260 // | |<-------------|
6262 //-----------------------------------------------------------------------------
6263 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
6264 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction")
6267 var params *teststube2ap.RESTSubsReqParams = nil
6268 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6271 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6273 // E2t: Receive 1st SubsDelReq
6274 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6276 mainCtrl.MakeTransactionNil(t, e2SubsId)
6278 // No transaction exist for this response which will result resending original request
6279 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6281 // E2t: Receive 2nd SubsDelReq
6282 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6284 // Subscription does not exist in in E2 Node.
6285 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6287 // Wait that subs is cleaned
6288 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6290 xappConn1.TestMsgChanEmpty(t)
6291 e2termConn1.TestMsgChanEmpty(t)
6292 mainCtrl.wait_registry_empty(t, 10)
6295 //-----------------------------------------------------------------------------
6296 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
6299 // +-------+ +---------+ +---------+
6300 // | xapp | | submgr | | e2term |
6301 // +-------+ +---------+ +---------+
6303 // | [SUBS CREATE] |
6306 // | RESTSubDelReq | |
6307 // |---------------->| |
6309 // | RESTSubDelResp | |
6310 // |<----------------| |
6313 // | |------------->|
6315 // | | SubDelFail | ASN.1 decode fails
6316 // | |<-------------|
6319 // | |------------->|
6321 // | | SubDelFail | Subscription does exist any more
6322 // | |<-------------|
6324 //-----------------------------------------------------------------------------
6325 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
6326 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail")
6329 var params *teststube2ap.RESTSubsReqParams = nil
6330 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6333 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6335 // E2t: Receive 1st SubsDelReq
6336 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6338 // Decode of this response fails which will result resending original request
6339 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
6341 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6342 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6344 // Subscription does not exist in in E2 Node.
6345 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6347 // Wait that subs is cleaned
6348 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6350 xappConn1.TestMsgChanEmpty(t)
6351 e2termConn1.TestMsgChanEmpty(t)
6352 mainCtrl.wait_registry_empty(t, 10)
6355 //-----------------------------------------------------------------------------
6356 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
6359 // +-------+ +---------+ +---------+
6360 // | xapp | | submgr | | e2term |
6361 // +-------+ +---------+ +---------+
6363 // | [SUBS CREATE] |
6366 // | RESTSubDelReq | |
6367 // |---------------->| |
6369 // | RESTSubDelResp | |
6370 // |<----------------| |
6373 // | |------------->|
6375 // | | SubDelFail | Unknown instanceId
6376 // | |<-------------|
6379 // | |------------->|
6381 // | | SubDelFail | Subscription does exist any more
6382 // | |<-------------|
6384 //-----------------------------------------------------------------------------
6385 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
6386 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId")
6389 var params *teststube2ap.RESTSubsReqParams = nil
6390 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6393 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6395 // E2t: Receive 1st SubsDelReq
6396 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6398 // Unknown instanceId in this response which will result resending original request
6399 delreq.RequestId.InstanceId = 0
6400 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6402 // E2t: Receive 2nd SubsDelReq
6403 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6405 // Subscription does not exist in in E2 Node.
6406 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6408 // Wait that subs is cleaned
6409 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6411 xappConn1.TestMsgChanEmpty(t)
6412 e2termConn1.TestMsgChanEmpty(t)
6413 mainCtrl.wait_registry_empty(t, 10)
6416 //-----------------------------------------------------------------------------
6417 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
6420 // +-------+ +---------+ +---------+
6421 // | xapp | | submgr | | e2term |
6422 // +-------+ +---------+ +---------+
6424 // | [SUBS CREATE] |
6427 // | RESTSubDelReq | |
6428 // |---------------->| |
6430 // | RESTSubDelResp | |
6431 // |<----------------| |
6434 // | |------------->|
6436 // | | SubDelFail | No transaction for the response
6437 // | |<-------------|
6440 // | |------------->|
6442 // | | SubDelFail | Subscription does exist any more
6443 // | |<-------------|
6445 //-----------------------------------------------------------------------------
6446 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
6447 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction")
6450 var params *teststube2ap.RESTSubsReqParams = nil
6451 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6454 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6456 // E2t: Receive 1st SubsDelReq
6457 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6459 mainCtrl.MakeTransactionNil(t, e2SubsId)
6461 // No transaction exist for this response which will result resending original request
6462 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6464 // E2t: Receive 2nd SubsDelReq
6465 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6467 // Subscription does not exist in in E2 Node.
6468 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6470 // Wait that subs is cleaned
6471 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6473 xappConn1.TestMsgChanEmpty(t)
6474 e2termConn1.TestMsgChanEmpty(t)
6475 mainCtrl.wait_registry_empty(t, 10)
6478 //-----------------------------------------------------------------------------
6479 // TestRESTSubReqFailAsn1PackSubReqError
6482 // +-------+ +---------+ +---------+
6483 // | xapp | | submgr | | e2term |
6484 // +-------+ +---------+ +---------+
6487 // |---------------->| |
6489 // | RESTSubResp | |
6490 // |<----------------| |
6492 // | ASN.1 encode fails |
6495 // | |------------->|
6498 // | |<-------------|
6502 // |<----------------| |
6504 // | [SUBS DELETE] |
6507 //-----------------------------------------------------------------------------
6508 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
6510 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6511 Counter{cRestSubReqFromXapp, 1},
6512 Counter{cRestSubRespToXapp, 1},
6513 Counter{cSubDelReqToE2, 1},
6514 Counter{cSubDelFailFromE2, 1},
6515 Counter{cRestSubFailNotifToXapp, 1},
6520 var params *teststube2ap.RESTSubsReqParams = nil
6521 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
6522 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
6525 restSubId := xappConn1.SendRESTSubsReq(t, params)
6526 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
6528 // E2t: Receive SubsDelReq
6529 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6530 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6532 // Subscription does not exist in in E2 Node.
6533 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6535 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6536 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
6538 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
6539 // Wait that subs is cleaned
6540 waitSubsCleanup(t, e2SubsId, 10)
6541 mainCtrl.VerifyCounterValues(t)
6544 ////////////////////////////////////////////////////////////////////////////////////
6545 // Services for UT cases
6546 ////////////////////////////////////////////////////////////////////////////////////
6547 const subReqCount int = 1
6548 const host string = "localhost"
6550 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
6552 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
6554 restSubId := fromXappConn.SendRESTSubsReq(t, params)
6555 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
6557 crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
6558 fromXappConn.ExpectRESTNotification(t, restSubId)
6559 toE2termConn.SendSubsResp(t, crereq1, cremsg1)
6560 e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
6561 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
6563 return restSubId, e2SubsId
6566 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
6568 params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
6570 params.SetMeid(meid)
6572 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
6573 restSubId := xappConn2.SendRESTSubsReq(t, params)
6574 xappConn2.ExpectRESTNotification(t, restSubId)
6575 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
6576 e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
6577 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
6579 return restSubId, e2SubsId
6582 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
6583 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6584 restSubId := xappConn1.SendRESTSubsReq(t, params)
6585 xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
6587 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6588 xappConn1.ExpectRESTNotification(t, restSubId)
6589 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
6590 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6591 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
6593 return restSubId, e2SubsId
6596 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
6597 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6598 restSubId := xappConn1.SendRESTSubsReq(t, params)
6600 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6601 fparams1 := &teststube2ap.E2StubSubsFailParams{}
6602 fparams1.Set(crereq1)
6603 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
6605 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
6606 xappConn1.ExpectRESTNotification(t, restSubId)
6607 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
6608 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6609 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
6611 return restSubId, e2SubsId
6614 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
6615 fromXappConn.SendRESTSubsDelReq(t, restSubId)
6616 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
6617 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
6620 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
6621 xappConn1.SendRESTSubsDelReq(t, restSubId)
6622 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6623 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6626 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
6627 xappConn2.SendRESTSubsDelReq(t, restSubId)
6628 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6629 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6632 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
6633 resp, _ := xapp.Subscription.QuerySubscriptions()
6634 assert.Equal(t, resp[0].SubscriptionID, e2SubsId)
6635 assert.Equal(t, resp[0].Meid, meid)
6636 assert.Equal(t, resp[0].ClientEndpoint, endpoint)
6639 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
6640 //Wait that subs is cleaned
6641 mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
6643 xappConn1.TestMsgChanEmpty(t)
6644 xappConn2.TestMsgChanEmpty(t)
6645 e2termConn1.TestMsgChanEmpty(t)
6646 mainCtrl.wait_registry_empty(t, timeout)
6649 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
6651 var e2SubsId []uint32
6653 for i := 0; i < count; i++ {
6654 xapp.Logger.Info("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
6655 crereq, cremsg := toE2termConn.RecvSubsReq(t)
6656 fromXappConn.ExpectRESTNotification(t, restSubId)
6657 toE2termConn.SendSubsResp(t, crereq, cremsg)
6658 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
6659 e2SubsId = append(e2SubsId, instanceId)
6660 xapp.Logger.Info("TEST: %v", e2SubsId)
6661 xapp.Logger.Info("TEST: %d ===================================== END CRE ============================================", i+1)
6662 <-time.After(100 * time.Millisecond)
6667 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
6669 for i := 0; i < len(e2SubsIds); i++ {
6670 xapp.Logger.Info("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
6671 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
6672 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
6673 <-time.After(1 * time.Second)
6674 xapp.Logger.Info("TEST: %d ===================================== END DEL ============================================", i+1)
6675 <-time.After(100 * time.Millisecond)
6678 // Wait that subs is cleaned
6679 for i := 0; i < len(e2SubsIds); i++ {
6680 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)