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())
43 //-----------------------------------------------------------------------------
44 // TestRESTSubReqAndDeleteOkWithE2apUtWrapper
47 // +-------+ +---------+ +---------+ +---------+
48 // | xapp | | submgr | | e2term | | rtmgr |
49 // +-------+ +---------+ +---------+ +---------+
52 // |---------------->| | |
53 // | | RouteCreate | |
54 // | |--------------------------->| // The order of these events may vary
56 // | RESTSubResp | | | // The order of these events may vary
57 // |<----------------| | |
58 // | | RouteResponse| |
59 // | |<---------------------------| // The order of these events may vary
62 // | |------------->| | // The order of these events may vary
65 // | |<-------------| |
67 // |<----------------| | |
69 // | RESTSubDelReq | | |
70 // |---------------->| | |
72 // | |------------->| |
74 // | RESTSubDelResp| | |
75 // |<----------------| | |
78 // | |<-------------| |
82 //-----------------------------------------------------------------------------
83 func TestRESTSubReqAndDeleteOkWithE2apUtWrapper(t *testing.T) {
85 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
87 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
89 waitSubsCleanup(t, e2SubsId, 10)
92 //-----------------------------------------------------------------------------
93 // TestRESTSubReqAndE1apDeleteReqPackingError
96 // +-------+ +---------+ +---------+ +---------+
97 // | xapp | | submgr | | e2term | | rtmgr |
98 // +-------+ +---------+ +---------+ +---------+
100 // | RESTSubReq | | |
101 // |---------------->| | |
102 // | | RouteCreate | |
103 // | |--------------------------->| // The order of these events may vary
105 // | RESTSubResp | | | // The order of these events may vary
106 // |<----------------| | |
107 // | | RouteResponse| |
108 // | |<---------------------------| // The order of these events may vary
111 // | |------------->| | // The order of these events may vary
114 // | |<-------------| |
115 // | RESTNotif1 | | |
116 // |<----------------| | |
118 // | RESTSubDelReq | | |
119 // |---------------->| | |
121 // | RESTSubDelResp| | |
122 // |<----------------| | |
126 //-----------------------------------------------------------------------------
127 func TestRESTSubReqAndE1apDeleteReqPackingError(t *testing.T) {
129 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
131 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, false)
132 xappConn1.SendRESTSubsDelReq(t, &restSubId)
133 defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, true)
135 waitSubsCleanup(t, e2SubsId, 10)
138 //-----------------------------------------------------------------------------
139 // TestRESTSubReqAndE1apDeleteRespUnpackingError
142 // +-------+ +---------+ +---------+ +---------+
143 // | xapp | | submgr | | e2term | | rtmgr |
144 // +-------+ +---------+ +---------+ +---------+
146 // | RESTSubReq | | |
147 // |---------------->| | |
148 // | | RouteCreate | |
149 // | |--------------------------->| // The order of these events may vary
151 // | RESTSubResp | | | // The order of these events may vary
152 // |<----------------| | |
153 // | | RouteResponse| |
154 // | |<---------------------------| // The order of these events may vary
157 // | |------------->| | // The order of these events may vary
160 // | |<-------------| |
161 // | RESTNotif1 | | |
162 // |<----------------| | |
164 // | RESTSubDelReq | | |
165 // |---------------->| | |
167 // | |------------->| |
169 // | RESTSubDelResp| | |
170 // |<----------------| | | // The order of these events may vary
172 // | | SubDelResp | |
173 // | |<-------------| | // 1.st NOK
176 // | |------------->| |
178 // | | SubDelResp | |
179 // | |<-------------| | // 2.nd NOK
181 //-----------------------------------------------------------------------------
183 func TestRESTSubReqAndE1apDeleteRespUnpackingError(t *testing.T) {
185 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
187 xappConn1.SendRESTSubsDelReq(t, &restSubId)
188 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, false)
189 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
190 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
192 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
193 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
195 defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, true)
197 waitSubsCleanup(t, e2SubsId, 10)
200 //-----------------------------------------------------------------------------
201 // TestSubReqAndRouteNok
204 // +-------+ +---------+ +---------+
205 // | xapp | | submgr | | rtmgr |
206 // +-------+ +---------+ +---------+
209 // |------------->| |
212 // | |------------->|
216 // | |<-------------|
218 // | [SUBS INT DELETE] |
221 //-----------------------------------------------------------------------------
223 func TestSubReqAndRouteNok(t *testing.T) {
224 CaseBegin("TestSubReqAndRouteNok")
226 // Init counter check
227 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
228 Counter{cSubReqFromXapp, 1},
229 Counter{cRouteCreateFail, 1},
232 waiter := rtmgrHttp.AllocNextEvent(false)
233 newSubsId := mainCtrl.get_registry_next_subid(t)
234 xappConn1.SendSubsReq(t, nil, nil)
237 //Wait that subs is cleaned
238 mainCtrl.wait_subs_clean(t, newSubsId, 10)
240 xappConn1.TestMsgChanEmpty(t)
241 xappConn2.TestMsgChanEmpty(t)
242 e2termConn1.TestMsgChanEmpty(t)
243 mainCtrl.wait_registry_empty(t, 10)
245 <-time.After(1 * time.Second)
246 mainCtrl.VerifyCounterValues(t)
249 //-----------------------------------------------------------------------------
250 // TestSubReqAndRouteUpdateNok
253 // +-------+ +-------+ +---------+ +---------+
254 // | xapp2 | | xapp1 | | submgr | | rtmgr |
255 // +-------+ +-------+ +---------+ +---------+
257 // | [SUBS CREATE] | |
261 // | SubReq (mergeable) | |
262 // |--------------------------->| | |
264 // | | | RouteUpdate |
265 // | | |------------->|
267 // | | | RouteUpdate |
268 // | | | status:400 |
269 // | | |<-------------|
271 // | [SUBS INT DELETE] | |
274 // | [SUBS DELETE] | |
277 func TestSubReqAndRouteUpdateNok(t *testing.T) {
278 CaseBegin("TestSubReqAndRouteUpdateNok")
280 // Init counter check
281 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
282 Counter{cSubReqFromXapp, 2},
283 Counter{cSubReqToE2, 1},
284 Counter{cSubRespFromE2, 1},
285 Counter{cSubRespToXapp, 1},
286 Counter{cRouteCreateUpdateFail, 1},
287 Counter{cSubDelReqFromXapp, 1},
288 Counter{cSubDelReqToE2, 1},
289 Counter{cSubDelRespFromE2, 1},
290 Counter{cSubDelRespToXapp, 1},
293 cretrans := xappConn1.SendSubsReq(t, nil, nil)
294 crereq, cremsg := e2termConn1.RecvSubsReq(t)
295 e2termConn1.SendSubsResp(t, crereq, cremsg)
296 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
298 resp, _ := xapp.Subscription.QuerySubscriptions()
299 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
300 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
301 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
303 waiter := rtmgrHttp.AllocNextEvent(false)
304 newSubsId := mainCtrl.get_registry_next_subid(t)
305 xappConn2.SendSubsReq(t, nil, nil)
308 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
309 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
311 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
312 xappConn1.RecvSubsDelResp(t, deltrans)
314 //Wait that subs is cleaned
315 mainCtrl.wait_subs_clean(t, newSubsId, 10)
316 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
318 xappConn1.TestMsgChanEmpty(t)
319 xappConn2.TestMsgChanEmpty(t)
320 e2termConn1.TestMsgChanEmpty(t)
321 mainCtrl.wait_registry_empty(t, 10)
323 mainCtrl.VerifyCounterValues(t)
326 //-----------------------------------------------------------------------------
327 // TestSubDelReqAndRouteDeleteNok
330 // +-------+ +---------+ +---------+ +---------+
331 // | xapp | | submgr | | e2term | | rtmgr |
332 // +-------+ +---------+ +---------+ +---------+
334 // | [SUBS CREATE] | |
339 // |------------->| | |
341 // | |------------->| |
343 // | |<-------------| |
345 // |<-------------| | |
346 // | | RouteDelete | |
347 // | |---------------------------->|
349 // | | RouteDelete | |
350 // | | status:400 | |
351 // | |<----------------------------|
353 func TestSubDelReqAndRouteDeleteNok(t *testing.T) {
354 CaseBegin("TestSubDelReqAndRouteDeleteNok")
356 // Init counter check
357 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
358 Counter{cSubReqFromXapp, 1},
359 Counter{cSubReqToE2, 1},
360 Counter{cSubRespFromE2, 1},
361 Counter{cSubRespToXapp, 1},
362 Counter{cSubDelReqFromXapp, 1},
363 Counter{cRouteDeleteFail, 1},
364 Counter{cSubDelReqToE2, 1},
365 Counter{cSubDelRespFromE2, 1},
366 Counter{cSubDelRespToXapp, 1},
369 cretrans := xappConn1.SendSubsReq(t, nil, nil)
370 crereq, cremsg := e2termConn1.RecvSubsReq(t)
371 e2termConn1.SendSubsResp(t, crereq, cremsg)
372 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
374 resp, _ := xapp.Subscription.QuerySubscriptions()
375 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
376 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
377 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
379 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
380 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
382 waiter := rtmgrHttp.AllocNextEvent(false)
383 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
386 xappConn1.RecvSubsDelResp(t, deltrans)
388 //Wait that subs is cleaned
389 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
391 xappConn1.TestMsgChanEmpty(t)
392 xappConn2.TestMsgChanEmpty(t)
393 e2termConn1.TestMsgChanEmpty(t)
394 mainCtrl.wait_registry_empty(t, 10)
396 mainCtrl.VerifyCounterValues(t)
399 //-----------------------------------------------------------------------------
400 // TestSubMergeDelAndRouteUpdateNok
402 // +-------+ +-------+ +---------+ +---------+
403 // | xapp2 | | xapp1 | | submgr | | e2term |
404 // +-------+ +-------+ +---------+ +---------+
409 // | |------------->| |
412 // | | |------------->|
414 // | | |<-------------|
416 // | |<-------------| |
419 // |--------------------------->| |
422 // |<---------------------------| |
424 // | | SubDelReq 1 | |
425 // | |------------->| |
426 // | | | RouteUpdate |
427 // | | |-----> rtmgr |
429 // | | | RouteUpdate |
430 // | | | status:400 |
431 // | | |<----- rtmgr |
433 // | | SubDelResp 1 | |
434 // | |<-------------| |
437 // |--------------------------->| |
439 // | | | SubDelReq 2 |
440 // | | |------------->|
442 // | | | SubDelReq 2 |
443 // | | |------------->|
445 // | SubDelResp 2 | |
446 // |<---------------------------| |
448 //-----------------------------------------------------------------------------
449 func TestSubMergeDelAndRouteUpdateNok(t *testing.T) {
450 CaseBegin("TestSubMergeDelAndRouteUpdateNok")
452 // Init counter check
453 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
454 Counter{cSubReqFromXapp, 2},
455 Counter{cSubReqToE2, 1},
456 Counter{cSubRespFromE2, 1},
457 Counter{cSubRespToXapp, 2},
458 Counter{cSubDelReqFromXapp, 2},
459 Counter{cRouteDeleteUpdateFail, 1},
460 Counter{cSubDelReqToE2, 1},
461 Counter{cSubDelRespFromE2, 1},
462 Counter{cSubDelRespToXapp, 2},
466 rparams1 := &teststube2ap.E2StubSubsReqParams{}
468 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
469 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
470 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
471 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
474 rparams2 := &teststube2ap.E2StubSubsReqParams{}
476 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
477 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
479 resp, _ := xapp.Subscription.QuerySubscriptions()
480 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
481 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
482 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
485 waiter := rtmgrHttp.AllocNextEvent(false)
486 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
489 xappConn1.RecvSubsDelResp(t, deltrans1)
492 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
493 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
494 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
495 xappConn2.RecvSubsDelResp(t, deltrans2)
496 //Wait that subs is cleaned
497 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
499 xappConn1.TestMsgChanEmpty(t)
500 xappConn2.TestMsgChanEmpty(t)
501 e2termConn1.TestMsgChanEmpty(t)
502 mainCtrl.wait_registry_empty(t, 10)
504 mainCtrl.VerifyCounterValues(t)
507 //-----------------------------------------------------------------------------
509 //-----------------------------------------------------------------------------
510 // TestSubReqAndSubDelOk
513 // +-------+ +---------+ +---------+
514 // | xapp | | submgr | | e2term |
515 // +-------+ +---------+ +---------+
518 // |------------->| |
521 // | |------------->|
524 // | |<-------------|
527 // |<-------------| |
531 // |------------->| |
534 // | |------------->|
537 // | |<-------------|
540 // |<-------------| |
542 //-----------------------------------------------------------------------------
543 func TestSubReqAndSubDelOk(t *testing.T) {
544 CaseBegin("TestSubReqAndSubDelOk")
546 // Init counter check
547 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
548 Counter{cSubReqFromXapp, 1},
549 Counter{cSubReqToE2, 1},
550 Counter{cSubRespFromE2, 1},
551 Counter{cSubRespToXapp, 1},
552 Counter{cSubDelReqFromXapp, 1},
553 Counter{cSubDelReqToE2, 1},
554 Counter{cSubDelRespFromE2, 1},
555 Counter{cSubDelRespToXapp, 1},
558 cretrans := xappConn1.SendSubsReq(t, nil, nil)
559 crereq, cremsg := e2termConn1.RecvSubsReq(t)
560 e2termConn1.SendSubsResp(t, crereq, cremsg)
561 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
563 resp, _ := xapp.Subscription.QuerySubscriptions()
564 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
565 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
566 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
568 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
569 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
571 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
572 xappConn1.RecvSubsDelResp(t, deltrans)
574 //Wait that subs is cleaned
575 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
577 xappConn1.TestMsgChanEmpty(t)
578 xappConn2.TestMsgChanEmpty(t)
579 e2termConn1.TestMsgChanEmpty(t)
580 mainCtrl.wait_registry_empty(t, 10)
582 mainCtrl.VerifyCounterValues(t)
585 //-----------------------------------------------------------------------------
586 // TestSubReqRetransmission
589 // +-------+ +---------+ +---------+
590 // | xapp | | submgr | | e2term |
591 // +-------+ +---------+ +---------+
594 // |------------->| |
597 // | |------------->|
601 // |------------->| |
604 // | |<-------------|
607 // |<-------------| |
612 //-----------------------------------------------------------------------------
613 func TestSubReqRetransmission(t *testing.T) {
614 CaseBegin("TestSubReqRetransmission")
617 cretrans := xappConn1.SendSubsReq(t, nil, nil)
618 crereq, cremsg := e2termConn1.RecvSubsReq(t)
620 seqBef := mainCtrl.get_msgcounter(t)
621 xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq
622 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
624 // hack as there is no real way to see has message be handled.
625 // Previuos counter check just tells that is has been received by submgr
626 // --> artificial delay
627 <-time.After(1 * time.Second)
628 e2termConn1.SendSubsResp(t, crereq, cremsg)
629 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
632 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
633 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
634 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
635 xappConn1.RecvSubsDelResp(t, deltrans)
637 //Wait that subs is cleaned
638 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
640 xappConn1.TestMsgChanEmpty(t)
641 xappConn2.TestMsgChanEmpty(t)
642 e2termConn1.TestMsgChanEmpty(t)
643 mainCtrl.wait_registry_empty(t, 10)
646 //-----------------------------------------------------------------------------
647 // TestSubDelReqRetransmission
650 // +-------+ +---------+ +---------+
651 // | xapp | | submgr | | e2term |
652 // +-------+ +---------+ +---------+
658 // |------------->| |
661 // | |------------->|
666 // |------------->| |
669 // | |<-------------|
672 // |<-------------| |
674 //-----------------------------------------------------------------------------
675 func TestSubDelReqRetransmission(t *testing.T) {
676 CaseBegin("TestSubDelReqRetransmission")
679 cretrans := xappConn1.SendSubsReq(t, nil, nil)
680 crereq, cremsg := e2termConn1.RecvSubsReq(t)
681 e2termConn1.SendSubsResp(t, crereq, cremsg)
682 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
685 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
686 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
688 seqBef := mainCtrl.get_msgcounter(t)
689 xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq
690 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
692 // hack as there is no real way to see has message be handled.
693 // Previuos counter check just tells that is has been received by submgr
694 // --> artificial delay
695 <-time.After(1 * time.Second)
697 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
698 xappConn1.RecvSubsDelResp(t, deltrans)
700 //Wait that subs is cleaned
701 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
703 xappConn1.TestMsgChanEmpty(t)
704 xappConn2.TestMsgChanEmpty(t)
705 e2termConn1.TestMsgChanEmpty(t)
706 mainCtrl.wait_registry_empty(t, 10)
709 //-----------------------------------------------------------------------------
710 // TestSubDelReqCollision
713 // +-------+ +---------+ +---------+
714 // | xapp | | submgr | | e2term |
715 // +-------+ +---------+ +---------+
721 // |------------->| |
724 // | |------------->|
729 // |------------->| |
731 // | | SubDelResp 1 |
732 // | |<-------------|
734 // | SubDelResp 1 | |
735 // |<-------------| |
737 // | SubDelResp 2 | |
738 // |<-------------| |
740 //-----------------------------------------------------------------------------
742 func TestSubDelReqCollision(t *testing.T) {
743 CaseBegin("TestSubDelReqCollision")
746 cretrans := xappConn1.SendSubsReq(t, nil, nil)
747 crereq, cremsg := e2termConn1.RecvSubsReq(t)
748 e2termConn1.SendSubsResp(t, crereq, cremsg)
749 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
752 xappConn1.SendSubsDelReq(t, nil, e2SubsId)
753 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
755 // Subs Delete colliding
756 seqBef := mainCtrl.get_msgcounter(t)
757 deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
758 xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq
759 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
761 // hack as there is no real way to see has message be handled.
762 // Previuos counter check just tells that is has been received by submgr
763 // --> artificial delay
764 <-time.After(1 * time.Second)
766 // Del resp for first and second
767 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
769 // don't care in which order responses are received
770 xappConn1.RecvSubsDelResp(t, nil)
771 xappConn1.RecvSubsDelResp(t, nil)
773 //Wait that subs is cleaned
774 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
776 xappConn1.TestMsgChanEmpty(t)
777 xappConn2.TestMsgChanEmpty(t)
778 e2termConn1.TestMsgChanEmpty(t)
779 mainCtrl.wait_registry_empty(t, 10)
782 //-----------------------------------------------------------------------------
783 // TestSubReqAndSubDelOkTwoParallel
786 // +-------+ +-------+ +---------+ +---------+
787 // | xapp | | xapp | | submgr | | e2term |
788 // +-------+ +-------+ +---------+ +---------+
793 // | |------------->| |
796 // | | |------------->|
799 // |------------------------>| |
802 // | | |------------->|
805 // | | |<-------------|
807 // | |<-------------| |
810 // | | |<-------------|
812 // |<------------------------| |
814 // | | [SUBS 1 DELETE] |
816 // | | [SUBS 2 DELETE] |
819 //-----------------------------------------------------------------------------
821 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
822 CaseBegin("TestSubReqAndSubDelOkTwoParallel")
825 rparams1 := &teststube2ap.E2StubSubsReqParams{}
827 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
828 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
831 rparams2 := &teststube2ap.E2StubSubsReqParams{}
834 rparams2.Req.EventTriggerDefinition.Data.Length = 1
835 rparams2.Req.EventTriggerDefinition.Data.Data = make([]uint8, rparams2.Req.EventTriggerDefinition.Data.Length)
836 rparams2.Req.EventTriggerDefinition.Data.Data[0] = 2
838 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
839 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
842 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
843 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
846 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
847 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
850 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
851 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
852 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
853 xappConn1.RecvSubsDelResp(t, deltrans1)
854 //Wait that subs is cleaned
855 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
858 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
859 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
860 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
861 xappConn2.RecvSubsDelResp(t, deltrans2)
862 //Wait that subs is cleaned
863 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
865 xappConn1.TestMsgChanEmpty(t)
866 xappConn2.TestMsgChanEmpty(t)
867 e2termConn1.TestMsgChanEmpty(t)
868 mainCtrl.wait_registry_empty(t, 10)
871 //-----------------------------------------------------------------------------
872 // TestSameSubsDiffRan
873 // Same subscription to different RANs
876 // +-------+ +---------+ +---------+
877 // | xapp | | submgr | | e2term |
878 // +-------+ +---------+ +---------+
883 // |------------->| |
886 // | |------------->|
889 // | |<-------------|
892 // |<-------------| |
895 // |------------->| |
898 // | |------------->|
901 // | |<-------------|
904 // |<-------------| |
906 // | [SUBS r1 DELETE] |
908 // | [SUBS r2 DELETE] |
911 //-----------------------------------------------------------------------------
912 func TestSameSubsDiffRan(t *testing.T) {
913 CaseBegin("TestSameSubsDiffRan")
916 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
917 xappConn1.SendSubsReq(t, nil, cretrans1)
918 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
919 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
920 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
923 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
924 xappConn1.SendSubsReq(t, nil, cretrans2)
925 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
926 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
927 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
930 deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
931 xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
932 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
933 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
934 xappConn1.RecvSubsDelResp(t, deltrans1)
935 //Wait that subs is cleaned
936 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
939 deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
940 xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
941 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
942 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
943 xappConn1.RecvSubsDelResp(t, deltrans2)
944 //Wait that subs is cleaned
945 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
947 xappConn1.TestMsgChanEmpty(t)
948 xappConn2.TestMsgChanEmpty(t)
949 e2termConn1.TestMsgChanEmpty(t)
950 mainCtrl.wait_registry_empty(t, 10)
953 //-----------------------------------------------------------------------------
954 // TestSubReqRetryInSubmgr
957 // +-------+ +---------+ +---------+
958 // | xapp | | submgr | | e2term |
959 // +-------+ +---------+ +---------+
962 // |------------->| |
965 // | |------------->|
969 // | |------------->|
972 // | |<-------------|
975 // |<-------------| |
980 //-----------------------------------------------------------------------------
982 func TestSubReqRetryInSubmgr(t *testing.T) {
983 CaseBegin("TestSubReqRetryInSubmgr start")
985 // Init counter check
986 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
987 Counter{cSubReqFromXapp, 1},
988 Counter{cSubReqToE2, 1},
989 Counter{cSubReReqToE2, 1},
990 Counter{cSubRespFromE2, 1},
991 Counter{cSubRespToXapp, 1},
992 Counter{cSubDelReqFromXapp, 1},
993 Counter{cSubDelReqToE2, 1},
994 Counter{cSubDelRespFromE2, 1},
995 Counter{cSubDelRespToXapp, 1},
998 // Xapp: Send SubsReq
999 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1001 // E2t: Receive 1st SubsReq
1002 e2termConn1.RecvSubsReq(t)
1004 // E2t: Receive 2nd SubsReq and send SubsResp
1005 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1006 e2termConn1.SendSubsResp(t, crereq, cremsg)
1008 // Xapp: Receive SubsResp
1009 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1011 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1012 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1013 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1014 xappConn1.RecvSubsDelResp(t, deltrans)
1016 // Wait that subs is cleaned
1017 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1019 xappConn1.TestMsgChanEmpty(t)
1020 xappConn2.TestMsgChanEmpty(t)
1021 e2termConn1.TestMsgChanEmpty(t)
1022 mainCtrl.wait_registry_empty(t, 10)
1024 mainCtrl.VerifyCounterValues(t)
1027 //-----------------------------------------------------------------------------
1028 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
1031 // +-------+ +---------+ +---------+
1032 // | xapp | | submgr | | e2term |
1033 // +-------+ +---------+ +---------+
1036 // |------------->| |
1039 // | |------------->|
1043 // | |------------->|
1046 // | |------------->|
1049 // | |<-------------|
1052 //-----------------------------------------------------------------------------
1053 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
1054 CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
1056 // Init counter check
1057 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1058 Counter{cSubReqFromXapp, 1},
1059 Counter{cSubReqToE2, 1},
1060 Counter{cSubReReqToE2, 1},
1061 Counter{cSubReqTimerExpiry, 2},
1062 Counter{cSubDelReqToE2, 1},
1063 Counter{cSubDelRespFromE2, 1},
1066 // Xapp: Send SubsReq
1067 xappConn1.SendSubsReq(t, nil, nil)
1069 // E2t: Receive 1st SubsReq
1070 e2termConn1.RecvSubsReq(t)
1072 // E2t: Receive 2nd SubsReq
1073 e2termConn1.RecvSubsReq(t)
1075 // E2t: Send receive SubsDelReq and send SubsResp
1076 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1077 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1079 // Wait that subs is cleaned
1080 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 10)
1082 xappConn1.TestMsgChanEmpty(t)
1083 xappConn2.TestMsgChanEmpty(t)
1084 e2termConn1.TestMsgChanEmpty(t)
1085 mainCtrl.wait_registry_empty(t, 10)
1087 mainCtrl.VerifyCounterValues(t)
1090 //-----------------------------------------------------------------------------
1091 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
1094 // +-------+ +---------+ +---------+
1095 // | xapp | | submgr | | e2term |
1096 // +-------+ +---------+ +---------+
1099 // |------------->| |
1102 // | |------------->|
1106 // | |------------->|
1109 // | |------------->|
1113 // | |------------->|
1117 //-----------------------------------------------------------------------------
1119 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
1120 CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
1122 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1123 Counter{cSubReqFromXapp, 1},
1124 Counter{cSubReqToE2, 1},
1125 Counter{cSubReReqToE2, 1},
1126 Counter{cSubReqTimerExpiry, 2},
1127 Counter{cSubDelReqToE2, 1},
1128 Counter{cSubDelReReqToE2, 1},
1129 Counter{cSubDelReqTimerExpiry, 2},
1132 // Xapp: Send SubsReq
1133 xappConn1.SendSubsReq(t, nil, nil)
1135 // E2t: Receive 1st SubsReq
1136 e2termConn1.RecvSubsReq(t)
1138 // E2t: Receive 2nd SubsReq
1139 e2termConn1.RecvSubsReq(t)
1141 // E2t: Receive 1st SubsDelReq
1142 e2termConn1.RecvSubsDelReq(t)
1144 // E2t: Receive 2nd SubsDelReq
1145 delreq, _ := e2termConn1.RecvSubsDelReq(t)
1147 // Wait that subs is cleaned
1148 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 15)
1150 xappConn1.TestMsgChanEmpty(t)
1151 xappConn2.TestMsgChanEmpty(t)
1152 e2termConn1.TestMsgChanEmpty(t)
1153 mainCtrl.wait_registry_empty(t, 10)
1155 mainCtrl.VerifyCounterValues(t)
1158 //-----------------------------------------------------------------------------
1159 // TestSubReqSubFailRespInSubmgr
1162 // +-------+ +---------+ +---------+
1163 // | xapp | | submgr | | e2term |
1164 // +-------+ +---------+ +---------+
1167 // |------------->| |
1170 // | |------------->|
1173 // | |<-------------|
1176 // | |------------->|
1179 // | |<-------------|
1182 // |<-------------| |
1185 //-----------------------------------------------------------------------------
1187 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1188 CaseBegin("TestSubReqSubFailRespInSubmgr start")
1190 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1191 Counter{cSubReqFromXapp, 1},
1192 Counter{cSubReqToE2, 1},
1193 Counter{cSubFailFromE2, 1},
1194 Counter{cSubFailToXapp, 1},
1197 // Xapp: Send SubsReq
1198 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1200 // E2t: Receive SubsReq and send SubsFail (first)
1201 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1202 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1203 fparams1.Set(crereq1)
1204 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1206 // E2t: Receive SubsDelReq and send SubsDelResp (internal first)
1207 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1208 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1210 // Xapp: Receive SubsFail
1211 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
1213 // Wait that subs is cleaned
1214 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1216 xappConn1.TestMsgChanEmpty(t)
1217 xappConn2.TestMsgChanEmpty(t)
1218 e2termConn1.TestMsgChanEmpty(t)
1219 mainCtrl.wait_registry_empty(t, 10)
1221 mainCtrl.VerifyCounterValues(t)
1224 //-----------------------------------------------------------------------------
1225 // TestSubDelReqRetryInSubmgr
1228 // +-------+ +---------+ +---------+
1229 // | xapp | | submgr | | e2term |
1230 // +-------+ +---------+ +---------+
1232 // | [SUBS CREATE] |
1236 // |------------->| |
1239 // | |------------->|
1242 // | |------------->|
1245 // | |<-------------|
1248 // |<-------------| |
1250 //-----------------------------------------------------------------------------
1252 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1254 CaseBegin("TestSubDelReqRetryInSubmgr start")
1257 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1258 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1259 e2termConn1.SendSubsResp(t, crereq, cremsg)
1260 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1263 // Xapp: Send SubsDelReq
1264 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1266 // E2t: Receive 1st SubsDelReq
1267 e2termConn1.RecvSubsDelReq(t)
1269 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1270 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1271 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1273 // Xapp: Receive SubsDelResp
1274 xappConn1.RecvSubsDelResp(t, deltrans)
1276 // Wait that subs is cleaned
1277 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1279 xappConn1.TestMsgChanEmpty(t)
1280 xappConn2.TestMsgChanEmpty(t)
1281 e2termConn1.TestMsgChanEmpty(t)
1282 mainCtrl.wait_registry_empty(t, 10)
1285 //-----------------------------------------------------------------------------
1286 // TestSubDelReqTwoRetriesNoRespInSubmgr
1289 // +-------+ +---------+ +---------+
1290 // | xapp | | submgr | | e2term |
1291 // +-------+ +---------+ +---------+
1293 // | [SUBS CREATE] |
1297 // |------------->| |
1300 // | |------------->|
1303 // | |------------->|
1307 // |<-------------| |
1309 //-----------------------------------------------------------------------------
1311 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1313 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
1316 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1317 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1318 e2termConn1.SendSubsResp(t, crereq, cremsg)
1319 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1322 // Xapp: Send SubsDelReq
1323 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1325 // E2t: Receive 1st SubsDelReq
1326 e2termConn1.RecvSubsDelReq(t)
1328 // E2t: Receive 2nd SubsDelReq
1329 e2termConn1.RecvSubsDelReq(t)
1331 // Xapp: Receive SubsDelResp
1332 xappConn1.RecvSubsDelResp(t, deltrans)
1334 // Wait that subs is cleaned
1335 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1337 xappConn1.TestMsgChanEmpty(t)
1338 xappConn2.TestMsgChanEmpty(t)
1339 e2termConn1.TestMsgChanEmpty(t)
1340 mainCtrl.wait_registry_empty(t, 10)
1343 //-----------------------------------------------------------------------------
1344 // TestSubDelReqSubDelFailRespInSubmgr
1347 // +-------+ +---------+ +---------+
1348 // | xapp | | submgr | | e2term |
1349 // +-------+ +---------+ +---------+
1351 // | [SUBS CREATE] |
1355 // |------------->| |
1358 // | |------------->|
1361 // | |<-------------|
1364 // |<-------------| |
1367 //-----------------------------------------------------------------------------
1369 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1370 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1372 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1373 Counter{cSubReqFromXapp, 1},
1374 Counter{cSubReqToE2, 1},
1375 Counter{cSubRespFromE2, 1},
1376 Counter{cSubRespToXapp, 1},
1377 Counter{cSubDelReqFromXapp, 1},
1378 Counter{cSubDelReqToE2, 1},
1379 Counter{cSubDelFailFromE2, 1},
1380 Counter{cSubDelRespToXapp, 1},
1384 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1385 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1386 e2termConn1.SendSubsResp(t, crereq, cremsg)
1387 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1389 // Xapp: Send SubsDelReq
1390 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1392 // E2t: Send receive SubsDelReq and send SubsDelFail
1393 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1394 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1396 // Xapp: Receive SubsDelResp
1397 xappConn1.RecvSubsDelResp(t, deltrans)
1399 // Wait that subs is cleaned
1400 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1402 xappConn1.TestMsgChanEmpty(t)
1403 xappConn2.TestMsgChanEmpty(t)
1404 e2termConn1.TestMsgChanEmpty(t)
1405 mainCtrl.wait_registry_empty(t, 10)
1407 mainCtrl.VerifyCounterValues(t)
1410 //-----------------------------------------------------------------------------
1411 // TestSubReqAndSubDelOkSameAction
1414 // +-------+ +-------+ +---------+ +---------+
1415 // | xapp2 | | xapp1 | | submgr | | e2term |
1416 // +-------+ +-------+ +---------+ +---------+
1421 // | |------------->| |
1424 // | | |------------->|
1426 // | | |<-------------|
1428 // | |<-------------| |
1431 // |--------------------------->| |
1434 // |<---------------------------| |
1436 // | | SubDelReq 1 | |
1437 // | |------------->| |
1439 // | | SubDelResp 1 | |
1440 // | |<-------------| |
1442 // | SubDelReq 2 | |
1443 // |--------------------------->| |
1445 // | | | SubDelReq 2 |
1446 // | | |------------->|
1448 // | | | SubDelReq 2 |
1449 // | | |------------->|
1451 // | SubDelResp 2 | |
1452 // |<---------------------------| |
1454 //-----------------------------------------------------------------------------
1455 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
1456 CaseBegin("TestSubReqAndSubDelOkSameAction")
1458 // Init counter check
1459 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1460 Counter{cSubReqFromXapp, 2},
1461 Counter{cSubReqToE2, 1},
1462 Counter{cSubRespFromE2, 1},
1463 Counter{cSubRespToXapp, 2},
1464 Counter{cMergedSubscriptions, 1},
1465 Counter{cUnmergedSubscriptions, 1},
1466 Counter{cSubDelReqFromXapp, 2},
1467 Counter{cSubDelReqToE2, 1},
1468 Counter{cSubDelRespFromE2, 1},
1469 Counter{cSubDelRespToXapp, 2},
1473 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1475 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1476 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1477 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1478 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1481 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1483 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1484 //crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1485 //e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1486 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1488 resp, _ := xapp.Subscription.QuerySubscriptions()
1489 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1490 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1491 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
1494 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1495 //e2termConn1.RecvSubsDelReq(t)
1496 //e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1497 xappConn1.RecvSubsDelResp(t, deltrans1)
1498 //Wait that subs is cleaned
1499 //mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1502 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1503 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1504 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1505 xappConn2.RecvSubsDelResp(t, deltrans2)
1506 //Wait that subs is cleaned
1507 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1509 xappConn1.TestMsgChanEmpty(t)
1510 xappConn2.TestMsgChanEmpty(t)
1511 e2termConn1.TestMsgChanEmpty(t)
1512 mainCtrl.wait_registry_empty(t, 10)
1514 mainCtrl.VerifyCounterValues(t)
1517 //-----------------------------------------------------------------------------
1518 // TestSubReqAndSubDelOkSameActionParallel
1521 // +-------+ +-------+ +---------+ +---------+
1522 // | xapp2 | | xapp1 | | submgr | | e2term |
1523 // +-------+ +-------+ +---------+ +---------+
1528 // | |------------->| |
1531 // | | |------------->|
1533 // |--------------------------->| |
1535 // | | |<-------------|
1537 // | |<-------------| |
1540 // |<---------------------------| |
1542 // | | SubDelReq 1 | |
1543 // | |------------->| |
1545 // | | SubDelResp 1 | |
1546 // | |<-------------| |
1548 // | SubDelReq 2 | |
1549 // |--------------------------->| |
1551 // | | | SubDelReq 2 |
1552 // | | |------------->|
1554 // | | | SubDelReq 2 |
1555 // | | |------------->|
1557 // | SubDelResp 2 | |
1558 // |<---------------------------| |
1560 //-----------------------------------------------------------------------------
1561 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1562 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1565 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1567 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1568 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1571 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1573 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1576 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1577 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1580 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1583 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1584 xappConn1.RecvSubsDelResp(t, deltrans1)
1587 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1588 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1589 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1590 xappConn2.RecvSubsDelResp(t, deltrans2)
1592 //Wait that subs is cleaned
1593 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1595 xappConn1.TestMsgChanEmpty(t)
1596 xappConn2.TestMsgChanEmpty(t)
1597 e2termConn1.TestMsgChanEmpty(t)
1598 mainCtrl.wait_registry_empty(t, 10)
1601 //-----------------------------------------------------------------------------
1602 // TestSubReqAndSubDelNokSameActionParallel
1605 // +-------+ +-------+ +---------+ +---------+
1606 // | xapp2 | | xapp1 | | submgr | | e2term |
1607 // +-------+ +-------+ +---------+ +---------+
1612 // | |------------->| |
1615 // | | |------------->|
1617 // |--------------------------->| |
1619 // | | |<-------------|
1621 // | | | SubDelReq |
1622 // | | |------------->|
1623 // | | | SubDelResp |
1624 // | | |<-------------|
1627 // | |<-------------| |
1630 // |<---------------------------| |
1632 //-----------------------------------------------------------------------------
1633 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1634 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1637 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1639 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1641 // E2t: Receive SubsReq (first)
1642 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1645 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1647 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1648 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1649 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1651 // E2t: send SubsFail (first)
1652 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1653 fparams1.Set(crereq1)
1654 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1656 // E2t: internal delete
1657 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1658 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1661 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1663 xappConn2.RecvSubsFail(t, cretrans2)
1665 //Wait that subs is cleaned
1666 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1668 xappConn1.TestMsgChanEmpty(t)
1669 xappConn2.TestMsgChanEmpty(t)
1670 e2termConn1.TestMsgChanEmpty(t)
1671 mainCtrl.wait_registry_empty(t, 10)
1674 //-----------------------------------------------------------------------------
1675 // TestSubReqAndSubDelNoAnswerSameActionParallel
1678 // +-------+ +-------+ +---------+ +---------+
1679 // | xapp2 | | xapp1 | | submgr | | e2term |
1680 // +-------+ +-------+ +---------+ +---------+
1685 // | |------------->| |
1688 // | | |------------->|
1690 // |--------------------------->| |
1693 // | | |------------->|
1696 // | | | SubDelReq |
1697 // | | |------------->|
1699 // | | | SubDelResp |
1700 // | | |<-------------|
1702 //-----------------------------------------------------------------------------
1703 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1704 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1707 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1709 xappConn1.SendSubsReq(t, rparams1, nil)
1711 crereq1, _ := e2termConn1.RecvSubsReq(t)
1714 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1716 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1717 xappConn2.SendSubsReq(t, rparams2, nil)
1718 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1720 //Req1 (retransmitted)
1721 e2termConn1.RecvSubsReq(t)
1723 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1724 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1726 //Wait that subs is cleaned
1727 mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10)
1729 xappConn1.TestMsgChanEmpty(t)
1730 xappConn2.TestMsgChanEmpty(t)
1731 e2termConn1.TestMsgChanEmpty(t)
1732 mainCtrl.wait_registry_empty(t, 15)
1735 //----------------------------- Policy cases ---------------------------------
1736 //-----------------------------------------------------------------------------
1737 // TestSubReqPolicyAndSubDelOk
1740 // +-------+ +---------+ +---------+
1741 // | xapp | | submgr | | e2term |
1742 // +-------+ +---------+ +---------+
1745 // |------------->| |
1748 // | |------------->|
1751 // | |<-------------|
1754 // |<-------------| |
1758 // |------------->| |
1761 // | |------------->|
1764 // | |<-------------|
1767 // |<-------------| |
1769 //-----------------------------------------------------------------------------
1770 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
1771 CaseBegin("TestSubReqAndSubDelOk")
1773 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1775 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1776 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1778 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1779 e2termConn1.SendSubsResp(t, crereq, cremsg)
1780 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1781 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1782 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1784 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1785 xappConn1.RecvSubsDelResp(t, deltrans)
1787 //Wait that subs is cleaned
1788 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1790 xappConn1.TestMsgChanEmpty(t)
1791 xappConn2.TestMsgChanEmpty(t)
1792 e2termConn1.TestMsgChanEmpty(t)
1793 mainCtrl.wait_registry_empty(t, 10)
1796 //-----------------------------------------------------------------------------
1797 // TestSubReqPolicyChangeAndSubDelOk
1800 // +-------+ +---------+ +---------+
1801 // | xapp | | submgr | | e2term |
1802 // +-------+ +---------+ +---------+
1805 // |------------->| |
1808 // | |------------->|
1811 // | |<-------------|
1814 // |<-------------| |
1817 // |------------->| |
1820 // | |------------->|
1823 // | |<-------------|
1826 // |<-------------| |
1829 // |------------->| |
1832 // | |------------->|
1835 // | |<-------------|
1838 // |<-------------| |
1840 //-----------------------------------------------------------------------------
1842 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
1843 CaseBegin("TestSubReqAndSubDelOk")
1845 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1847 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1848 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1850 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1851 e2termConn1.SendSubsResp(t, crereq, cremsg)
1852 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1855 rparams1.Req.RequestId.InstanceId = e2SubsId
1856 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
1857 xappConn1.SendSubsReq(t, rparams1, cretrans)
1859 crereq, cremsg = e2termConn1.RecvSubsReq(t)
1860 e2termConn1.SendSubsResp(t, crereq, cremsg)
1861 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1862 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1863 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1865 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1866 xappConn1.RecvSubsDelResp(t, deltrans)
1868 //Wait that subs is cleaned
1869 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1871 xappConn1.TestMsgChanEmpty(t)
1872 xappConn2.TestMsgChanEmpty(t)
1873 e2termConn1.TestMsgChanEmpty(t)
1874 mainCtrl.wait_registry_empty(t, 10)
1877 //-----------------------------------------------------------------------------
1878 // TestSubReqAndSubDelOkTwoE2termParallel
1881 // +-------+ +---------+ +---------+ +---------+
1882 // | xapp | | submgr | | e2term1 | | e2term2 |
1883 // +-------+ +---------+ +---------+ +---------+
1888 // |------------->| | |
1891 // | |------------->| |
1894 // |------------->| | |
1897 // | |---------------------------->|
1900 // | |<-------------| |
1902 // |<-------------| | |
1904 // | |<----------------------------|
1906 // |<-------------| | |
1908 // | [SUBS 1 DELETE] | |
1910 // | [SUBS 2 DELETE] | |
1913 //-----------------------------------------------------------------------------
1914 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
1915 CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
1918 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1919 xappConn1.SendSubsReq(t, nil, cretrans1)
1920 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1922 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
1923 xappConn1.SendSubsReq(t, nil, cretrans2)
1924 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
1927 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1928 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1931 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
1932 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1935 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1936 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1937 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1938 xappConn1.RecvSubsDelResp(t, deltrans1)
1939 //Wait that subs is cleaned
1940 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1943 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
1944 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
1945 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
1946 xappConn1.RecvSubsDelResp(t, deltrans2)
1947 //Wait that subs is cleaned
1948 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1950 xappConn1.TestMsgChanEmpty(t)
1951 xappConn2.TestMsgChanEmpty(t)
1952 e2termConn1.TestMsgChanEmpty(t)
1953 e2termConn2.TestMsgChanEmpty(t)
1954 mainCtrl.wait_registry_empty(t, 10)
1957 //-----------------------------------------------------------------------------
1958 // TestSubReqInsertAndSubDelOk
1961 // +-------+ +---------+ +---------+
1962 // | xapp | | submgr | | e2term |
1963 // +-------+ +---------+ +---------+
1966 // |------------->| |
1969 // | |------------->|
1972 // | |<-------------|
1975 // |<-------------| |
1979 // |------------->| |
1982 // | |------------->|
1985 // | |<-------------|
1988 // |<-------------| |
1990 //-----------------------------------------------------------------------------
1991 func TestSubReqInsertAndSubDelOk(t *testing.T) {
1992 CaseBegin("TestInsertSubReqAndSubDelOk")
1994 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1996 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeInsert
1997 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1999 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2000 e2termConn1.SendSubsResp(t, crereq, cremsg)
2001 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2002 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2003 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2005 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2006 xappConn1.RecvSubsDelResp(t, deltrans)
2008 //Wait that subs is cleaned
2009 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2011 xappConn1.TestMsgChanEmpty(t)
2012 xappConn2.TestMsgChanEmpty(t)
2013 e2termConn1.TestMsgChanEmpty(t)
2014 mainCtrl.wait_registry_empty(t, 10)
2017 //-----------------------------------------------------------------------------
2018 // TestSubReqRetransmissionWithSameSubIdDiffXid
2020 // This case simulates case where xApp restarts and starts sending same
2021 // subscription requests which have already subscribed successfully
2024 // +-------+ +---------+ +---------+
2025 // | xapp | | submgr | | e2term |
2026 // +-------+ +---------+ +---------+
2029 // |------------->| |
2032 // | |------------->|
2035 // | |<-------------|
2038 // |<-------------| |
2040 // | xApp restart | |
2043 // | (retrans with same xApp generated subid but diff xid)
2044 // |------------->| |
2047 // |<-------------| |
2049 // | [SUBS DELETE] |
2052 //-----------------------------------------------------------------------------
2053 func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) {
2054 CaseBegin("TestSubReqRetransmissionWithSameSubIdDiffXid")
2057 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2058 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2059 e2termConn1.SendSubsResp(t, crereq, cremsg)
2060 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2062 // xApp restart here
2063 // --> artificial delay
2064 <-time.After(1 * time.Second)
2067 cretrans = xappConn1.SendSubsReq(t, nil, nil) //Retransmitted SubReq
2068 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2071 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2072 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2073 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2074 xappConn1.RecvSubsDelResp(t, deltrans)
2076 //Wait that subs is cleaned
2077 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2079 xappConn1.TestMsgChanEmpty(t)
2080 xappConn2.TestMsgChanEmpty(t)
2081 e2termConn1.TestMsgChanEmpty(t)
2082 mainCtrl.wait_registry_empty(t, 10)
2085 //-----------------------------------------------------------------------------
2086 // TestSubReqNokAndSubDelOkWithRestartInMiddle
2089 // +-------+ +---------+ +---------+
2090 // | xapp | | submgr | | e2term |
2091 // +-------+ +---------+ +---------+
2094 // |------------->| |
2097 // | |------------->|
2102 // | Submgr restart |
2106 // | |------------->|
2109 // | |<-------------|
2112 //-----------------------------------------------------------------------------
2114 func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
2115 CaseBegin("TestSubReqNokAndSubDelOkWithRestartInMiddle")
2117 // Remove possible existing subscrition
2118 mainCtrl.removeExistingSubscriptions(t)
2120 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
2121 xappConn1.SendSubsReq(t, nil, nil)
2122 e2termConn1.RecvSubsReq(t)
2123 mainCtrl.SetResetTestFlag(t, false)
2125 resp, _ := xapp.Subscription.QuerySubscriptions()
2126 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2127 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2128 e2SubsId := uint32(resp[0].SubscriptionID)
2129 t.Logf("e2SubsId = %v", e2SubsId)
2131 mainCtrl.SimulateRestart(t)
2132 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2134 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2135 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2137 // Wait that subs is cleaned
2138 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2140 xappConn1.TestMsgChanEmpty(t)
2141 xappConn2.TestMsgChanEmpty(t)
2142 e2termConn1.TestMsgChanEmpty(t)
2143 mainCtrl.wait_registry_empty(t, 10)
2146 //-----------------------------------------------------------------------------
2147 // TestSubReqAndSubDelOkWithRestartInMiddle
2150 // +-------+ +---------+ +---------+
2151 // | xapp | | submgr | | e2term |
2152 // +-------+ +---------+ +---------+
2155 // |------------->| |
2158 // | |------------->|
2161 // | |<-------------|
2164 // |<-------------| |
2167 // | Submgr restart |
2170 // |------------->| |
2173 // | |------------->|
2176 // | |<-------------|
2179 // |<-------------| |
2181 //-----------------------------------------------------------------------------
2183 func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
2184 CaseBegin("TestSubReqAndSubDelOkWithRestartInMiddle")
2186 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2187 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2188 e2termConn1.SendSubsResp(t, crereq, cremsg)
2189 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2191 // Check subscription
2192 resp, _ := xapp.Subscription.QuerySubscriptions()
2193 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2194 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2195 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2197 mainCtrl.SimulateRestart(t)
2198 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2200 // Check that subscription is restored correctly after restart
2201 resp, _ = xapp.Subscription.QuerySubscriptions()
2202 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2203 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2204 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2206 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2207 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2208 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2209 xappConn1.RecvSubsDelResp(t, deltrans)
2211 //Wait that subs is cleaned
2212 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2214 xappConn1.TestMsgChanEmpty(t)
2215 xappConn2.TestMsgChanEmpty(t)
2216 e2termConn1.TestMsgChanEmpty(t)
2217 mainCtrl.wait_registry_empty(t, 10)
2220 //-----------------------------------------------------------------------------
2221 // TestSubReqAndSubDelOkSameActionWithRestartsInMiddle
2224 // +-------+ +-------+ +---------+ +---------+
2225 // | xapp2 | | xapp1 | | submgr | | e2term |
2226 // +-------+ +-------+ +---------+ +---------+
2231 // | |------------->| |
2234 // | | |------------->|
2236 // | | |<-------------|
2238 // | |<-------------| |
2241 // | submgr restart |
2246 // |--------------------------->| |
2249 // |<---------------------------| |
2251 // | | SubDelReq 1 | |
2252 // | |------------->| |
2254 // | | SubDelResp 1 | |
2255 // | |<-------------| |
2259 // | submgr restart |
2262 // | SubDelReq 2 | |
2263 // |--------------------------->| |
2265 // | | | SubDelReq 2 |
2266 // | | |------------->|
2268 // | | | SubDelReq 2 |
2269 // | | |------------->|
2271 // | SubDelResp 2 | |
2272 // |<---------------------------| |
2274 //-----------------------------------------------------------------------------
2276 func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
2277 CaseBegin("TestSubReqAndSubDelOkSameActionWithRestartsInMiddle")
2280 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2282 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2283 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2284 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2285 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2288 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2290 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2291 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
2293 // Check subscription
2294 resp, _ := xapp.Subscription.QuerySubscriptions() ////////////////////////////////
2295 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2296 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2297 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2299 mainCtrl.SimulateRestart(t)
2300 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2302 // Check that subscription is restored correctly after restart
2303 resp, _ = xapp.Subscription.QuerySubscriptions()
2304 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2305 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2306 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2309 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2310 xapp.Logger.Debug("xappConn1.RecvSubsDelResp")
2311 xappConn1.RecvSubsDelResp(t, deltrans1)
2312 xapp.Logger.Debug("xappConn1.RecvSubsDelResp received")
2314 mainCtrl.SimulateRestart(t)
2315 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2318 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
2319 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2321 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2322 xappConn2.RecvSubsDelResp(t, deltrans2)
2324 //Wait that subs is cleaned
2325 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2327 xappConn1.TestMsgChanEmpty(t)
2328 xappConn2.TestMsgChanEmpty(t)
2329 e2termConn1.TestMsgChanEmpty(t)
2330 mainCtrl.wait_registry_empty(t, 10)
2333 //*****************************************************************************
2334 // REST interface test cases
2335 //*****************************************************************************
2337 //-----------------------------------------------------------------------------
2338 // Test debug GET and POST requests
2341 // +-------+ +---------+
2342 // | user | | submgr |
2343 // +-------+ +---------+
2350 func TestGetSubscriptions(t *testing.T) {
2352 mainCtrl.sendGetRequest(t, "localhost:8088", "/ric/v1/subscriptions")
2355 func TestGetSymptomData(t *testing.T) {
2357 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/symptomdata")
2360 func TestPostdeleteSubId(t *testing.T) {
2362 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/deletesubid=1")
2365 func TestPostEmptyDb(t *testing.T) {
2367 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/emptydb")
2370 //-----------------------------------------------------------------------------
2371 // TestRESTSubReqAndRouteNok
2374 // +-------+ +---------+ +---------+
2375 // | xapp | | submgr | | rtmgr |
2376 // +-------+ +---------+ +---------+
2379 // |---------------->| |
2381 // | RESTSubResp | |
2382 // |<----------------| |
2383 // | | RouteCreate |
2384 // | |------------->|
2386 // | | RouteCreate |
2388 // | |(Bad request) |
2389 // | |<-------------|
2391 // |<----------------| |
2393 // | [SUBS INT DELETE] |
2395 // | RESTSubDelReq | |
2396 // |---------------->| |
2397 // | RESTSubDelResp | |
2398 // |<----------------| |
2400 //-----------------------------------------------------------------------------
2401 func TestRESTSubReqAndRouteNok(t *testing.T) {
2402 CaseBegin("TestRESTSubReqAndRouteNok")
2404 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2405 Counter{cRestSubReqFromXapp, 1},
2406 Counter{cRestSubRespToXapp, 1},
2407 Counter{cRouteCreateFail, 1},
2408 Counter{cRestSubFailNotifToXapp, 1},
2409 Counter{cRestSubDelReqFromXapp, 1},
2410 Counter{cRestSubDelRespToXapp, 1},
2413 const subReqCount int = 1
2414 // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
2415 waiter := rtmgrHttp.AllocNextSleep(50, false)
2416 newSubsId := mainCtrl.get_registry_next_subid(t)
2419 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2420 restSubId := xappConn1.SendRESTSubsReq(t, params)
2421 xappConn1.ExpectRESTNotification(t, restSubId)
2422 waiter.WaitResult(t)
2424 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2425 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
2428 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2430 // Wait that subs is cleaned
2431 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2432 waitSubsCleanup(t, e2SubsId, 10)
2433 mainCtrl.VerifyCounterValues(t)
2436 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
2437 CaseBegin("TestSubReqAndRouteUpdateNok")
2439 //Init counter check
2440 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2441 Counter{cRestSubReqFromXapp, 2},
2442 Counter{cRestSubRespToXapp, 2},
2443 Counter{cSubReqToE2, 1},
2444 Counter{cSubRespFromE2, 1},
2445 Counter{cRestSubNotifToXapp, 1},
2446 Counter{cRestSubFailNotifToXapp, 1},
2447 Counter{cRouteCreateUpdateFail, 1},
2448 Counter{cRestSubDelReqFromXapp, 1},
2449 Counter{cSubDelReqToE2, 1},
2450 Counter{cSubDelRespFromE2, 1},
2451 Counter{cRestSubDelRespToXapp, 1},
2454 var params *teststube2ap.RESTSubsReqParams = nil
2457 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2459 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2461 // xapp2 ROUTE creation shall fail with 400 from rtmgr -> submgr
2462 waiter := rtmgrHttp.AllocNextEvent(false)
2463 newSubsId := mainCtrl.get_registry_next_subid(t)
2464 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
2465 params.SetMeid("RAN_NAME_1")
2466 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2467 xapp.Logger.Info("Send REST subscriber request for second subscriber : %v", restSubId2)
2468 xappConn2.ExpectRESTNotification(t, restSubId2)
2469 waiter.WaitResult(t)
2470 // e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) - TOD: missing delete
2471 xappConn2.WaitRESTNotification(t, restSubId2)
2473 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2475 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2477 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2478 //Wait that subs is cleaned
2479 waitSubsCleanup(t, e2SubsId, 10)
2481 mainCtrl.VerifyCounterValues(t)
2484 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
2485 CaseBegin("TestRESTSubDelReqAndRouteDeleteNok")
2487 // Init counter check
2488 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2489 Counter{cRestSubReqFromXapp, 1},
2490 Counter{cRestSubRespToXapp, 1},
2491 Counter{cSubReqToE2, 1},
2492 Counter{cSubRespFromE2, 1},
2493 Counter{cRestSubNotifToXapp, 1},
2494 Counter{cRestSubDelReqFromXapp, 1},
2495 Counter{cRouteDeleteFail, 1},
2496 Counter{cSubDelReqToE2, 1},
2497 Counter{cSubDelRespFromE2, 1},
2498 Counter{cRestSubDelRespToXapp, 1},
2501 var params *teststube2ap.RESTSubsReqParams = nil
2504 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2506 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2508 waiter := rtmgrHttp.AllocNextEvent(false)
2509 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2510 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2511 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2512 waiter.WaitResult(t)
2514 waitSubsCleanup(t, e2SubsId, 10)
2516 mainCtrl.VerifyCounterValues(t)
2519 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
2520 CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok")
2522 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2523 Counter{cRestSubReqFromXapp, 2},
2524 Counter{cRestSubRespToXapp, 2},
2525 Counter{cSubReqToE2, 1},
2526 Counter{cSubRespFromE2, 1},
2527 Counter{cRestSubNotifToXapp, 2},
2528 Counter{cRestSubDelReqFromXapp, 2},
2529 Counter{cRouteDeleteUpdateFail, 1},
2530 Counter{cSubDelReqToE2, 1},
2531 Counter{cSubDelRespFromE2, 1},
2532 Counter{cRestSubDelRespToXapp, 2},
2535 var params *teststube2ap.RESTSubsReqParams = nil
2538 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2540 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2541 restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1")
2543 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
2545 //Del1, this shall fail on rtmgr side
2546 waiter := rtmgrHttp.AllocNextEvent(false)
2547 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2548 waiter.WaitResult(t)
2550 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"})
2553 deleteXapp2Subscription(t, &restSubId2)
2555 waitSubsCleanup(t, e2SubsId2, 10)
2557 mainCtrl.VerifyCounterValues(t)
2560 //-----------------------------------------------------------------------------
2561 // TestRESTSubReqRetransmission
2564 // +-------+ +---------+ +---------+
2565 // | xapp | | submgr | | e2term |
2566 // +-------+ +---------+ +---------+
2568 // | RESTSubReq1 | |
2569 // |---------------->| |
2571 // | RESTSubResp | |
2572 // |<----------------| |
2574 // | |------------->|
2576 // | RESTSubReq2 | |
2578 // |---------------->| |
2581 // | |------------->|
2582 // | RESTSubResp2 | |
2583 // |<----------------| |
2585 // | |<-------------|
2587 // |<----------------| |
2589 // | |<-------------|
2591 // |<----------------| |
2593 // | [SUBS DELETE] |
2596 //-----------------------------------------------------------------------------
2598 func TestRESTSubReqRetransmission(t *testing.T) {
2599 CaseBegin("TestRESTSubReqRetransmission")
2601 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2602 Counter{cRestSubReqFromXapp, 2},
2603 Counter{cRestSubRespToXapp, 2},
2604 Counter{cSubReqToE2, 2},
2605 Counter{cSubRespFromE2, 2},
2606 Counter{cRestSubNotifToXapp, 2},
2607 Counter{cRestSubDelReqFromXapp, 2},
2608 Counter{cSubDelReqToE2, 2},
2609 Counter{cSubDelRespFromE2, 2},
2610 Counter{cRestSubDelRespToXapp, 2},
2612 // Retry/duplicate will get the same way as the first request. Submgr cannot detect duplicate RESTRequests
2613 // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
2614 // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
2617 const subReqCount int = 1
2619 // In order to force both XAPP's to create their own subscriptions, force rtmgr to block a while so that 2nd create
2620 // gets into execution before the rtmgrg responds for the first one.
2621 waiter := rtmgrHttp.AllocNextSleep(10, true)
2622 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2623 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
2624 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2626 waiter.WaitResult(t)
2628 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
2630 // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
2631 // the order is not significant he6re.
2632 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2633 e2termConn1.SendSubsResp(t, crereq, cremsg)
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)
2639 e2SubsIdB := <-xappConn1.ListedRESTNotifications
2640 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
2643 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
2644 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2645 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2648 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
2649 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2650 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2652 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
2654 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
2656 mainCtrl.VerifyCounterValues(t)
2659 func TestRESTSubDelReqRetransmission(t *testing.T) {
2660 CaseBegin("TestRESTSubDelReqRetransmission")
2662 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2663 Counter{cRestSubReqFromXapp, 1},
2664 Counter{cRestSubRespToXapp, 1},
2665 Counter{cSubReqToE2, 1},
2666 Counter{cSubRespFromE2, 1},
2667 Counter{cRestSubNotifToXapp, 1},
2668 Counter{cRestSubDelReqFromXapp, 2},
2669 Counter{cSubDelReqToE2, 1},
2670 Counter{cSubDelRespFromE2, 1},
2671 Counter{cRestSubDelRespToXapp, 1},
2674 var params *teststube2ap.RESTSubsReqParams = nil
2677 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2679 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2682 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2683 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2685 seqBef := mainCtrl.get_msgcounter(t)
2686 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2687 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
2689 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2691 waitSubsCleanup(t, e2SubsId, 10)
2693 mainCtrl.VerifyCounterValues(t)
2696 //-----------------------------------------------------------------------------
2697 // TestRESTSubReqDelReq
2700 // +-------+ +---------+ +---------+
2701 // | xapp | | submgr | | e2term |
2702 // +-------+ +---------+ +---------+
2705 // |---------------->| |
2707 // | RESTSubResp | |
2708 // |<----------------| |
2710 // | |------------->|
2711 // | RESTSubDelReq | |
2712 // |---------------->| |
2713 // | RESTSubDelResp | |
2715 // |<----------------| |
2717 // | |<-------------|
2719 // |<----------------| |
2721 // | [SUBS DELETE] |
2724 //-----------------------------------------------------------------------------
2725 func TestRESTSubReqDelReq(t *testing.T) {
2726 CaseBegin("TestRESTSubReqDelReq")
2728 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2729 Counter{cRestSubReqFromXapp, 1},
2730 Counter{cRestSubRespToXapp, 1},
2731 Counter{cSubReqToE2, 1},
2732 Counter{cSubRespFromE2, 1},
2733 Counter{cRestSubNotifToXapp, 1},
2734 Counter{cRestSubDelReqFromXapp, 2},
2735 Counter{cSubDelReqToE2, 1},
2736 Counter{cSubDelRespFromE2, 1},
2737 Counter{cRestSubDelRespToXapp, 1},
2740 const subReqCount int = 1
2743 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2744 restSubId := xappConn1.SendRESTSubsReq(t, params)
2746 // Del. This will fail as processing of the subscription
2747 // is still ongoing in submgr. Deletion is not allowed before
2748 // subscription creation has been completed.
2749 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2750 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2751 xappConn1.ExpectRESTNotification(t, restSubId)
2752 e2termConn1.SendSubsResp(t, crereq, cremsg)
2753 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2756 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2758 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2759 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2761 // Wait that subs is cleaned
2762 waitSubsCleanup(t, e2SubsId, 10)
2763 mainCtrl.VerifyCounterValues(t)
2767 func TestRESTSubDelReqCollision(t *testing.T) {
2768 CaseBegin("TestRESTSubDelReqCollision - not relevant for REST API")
2771 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
2772 CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel")
2774 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2775 Counter{cRestSubReqFromXapp, 2},
2776 Counter{cRestSubRespToXapp, 2},
2777 Counter{cSubReqToE2, 2},
2778 Counter{cSubRespFromE2, 2},
2779 Counter{cRestSubNotifToXapp, 2},
2780 Counter{cRestSubDelReqFromXapp, 2},
2781 Counter{cSubDelReqToE2, 2},
2782 Counter{cSubDelRespFromE2, 2},
2783 Counter{cRestSubDelRespToXapp, 2},
2787 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2788 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
2789 xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
2792 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
2793 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2794 xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
2796 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2797 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
2799 //XappConn1 receives both of the responses
2800 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
2803 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2805 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
2807 e2SubsIdA := <-xappConn1.ListedRESTNotifications
2808 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
2809 e2SubsIdB := <-xappConn1.ListedRESTNotifications
2810 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
2813 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
2815 deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
2817 //Wait that subs is cleaned
2818 mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
2819 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
2821 mainCtrl.VerifyCounterValues(t)
2825 func TestRESTSameSubsDiffRan(t *testing.T) {
2826 CaseBegin("TestRESTSameSubsDiffRan")
2828 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2829 Counter{cRestSubReqFromXapp, 2},
2830 Counter{cRestSubRespToXapp, 2},
2831 Counter{cSubReqToE2, 2},
2832 Counter{cSubRespFromE2, 2},
2833 Counter{cRestSubNotifToXapp, 2},
2834 Counter{cRestSubDelReqFromXapp, 2},
2835 Counter{cSubDelReqToE2, 2},
2836 Counter{cSubDelRespFromE2, 2},
2837 Counter{cRestSubDelRespToXapp, 2},
2840 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2841 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
2842 xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
2844 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
2845 params.SetMeid("RAN_NAME_2")
2846 restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
2847 xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
2850 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
2852 deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
2854 //Wait that subs is cleaned
2855 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
2856 waitSubsCleanup(t, e2SubsId2, 10)
2858 mainCtrl.VerifyCounterValues(t)
2862 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
2863 CaseBegin("TestRESTSubReqRetryInSubmgr start")
2865 // Init counter check
2866 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2867 Counter{cRestSubReqFromXapp, 1},
2868 Counter{cRestSubRespToXapp, 1},
2869 Counter{cSubReqToE2, 1},
2870 Counter{cSubReReqToE2, 1},
2871 Counter{cSubRespFromE2, 1},
2872 Counter{cRestSubNotifToXapp, 1},
2873 Counter{cRestSubDelReqFromXapp, 1},
2874 Counter{cSubDelReqToE2, 1},
2875 Counter{cSubDelRespFromE2, 1},
2876 Counter{cRestSubDelRespToXapp, 1},
2879 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2880 restSubId := xappConn1.SendRESTSubsReq(t, params)
2882 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
2884 // Catch the first message and ignore it
2885 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2886 xapp.Logger.Info("Ignore REST subscriber request for subscriber : %v", restSubId)
2888 // The second request is being handled normally
2889 crereq, cremsg = e2termConn1.RecvSubsReq(t)
2890 xappConn1.ExpectRESTNotification(t, restSubId)
2891 e2termConn1.SendSubsResp(t, crereq, cremsg)
2892 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2894 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2896 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2898 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2899 //Wait that subs is cleaned
2900 waitSubsCleanup(t, e2SubsId, 10)
2902 mainCtrl.VerifyCounterValues(t)
2906 //-----------------------------------------------------------------------------
2907 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
2910 // +-------+ +---------+ +---------+
2911 // | xapp | | submgr | | e2term |
2912 // +-------+ +---------+ +---------+
2915 // |---------------->| |
2917 // | RESTSubResp | |
2918 // |<----------------| |
2920 // | |------------->|
2924 // | |------------->|
2927 // | |------------->|
2931 // | |------------->|
2935 // | |<-------------|
2938 // |<----------------| |
2940 // | [SUBS DELETE] |
2943 //-----------------------------------------------------------------------------
2944 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
2945 CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
2947 // Init counter check
2948 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2949 Counter{cRestSubReqFromXapp, 1},
2950 Counter{cRestSubRespToXapp, 1},
2951 Counter{cSubReqToE2, 1},
2952 Counter{cSubReReqToE2, 1},
2953 Counter{cSubReqTimerExpiry, 2},
2954 Counter{cSubDelReqToE2, 1},
2955 Counter{cSubDelRespFromE2, 1},
2958 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2959 restSubId := xappConn1.SendRESTSubsReq(t, params)
2960 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
2962 e2termConn1.RecvSubsReq(t)
2963 xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
2965 e2termConn1.RecvSubsReq(t)
2966 xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
2968 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2969 xappConn1.ExpectRESTNotification(t, restSubId)
2970 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2971 // e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) - TODO: Should we delete this?
2972 xappConn1.WaitRESTNotification(t, restSubId)
2974 // Wait that subs is cleaned
2975 waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
2977 mainCtrl.VerifyCounterValues(t)
2980 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
2981 CaseBegin("TestREST2eTermNotRespondingToSubReq start")
2983 // Init counter check
2984 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2985 Counter{cRestSubReqFromXapp, 1},
2986 Counter{cRestSubRespToXapp, 1},
2987 Counter{cSubReqToE2, 1},
2988 Counter{cSubReReqToE2, 1},
2989 Counter{cSubReqTimerExpiry, 2},
2990 Counter{cSubDelReqToE2, 1},
2991 Counter{cSubDelReqTimerExpiry, 2},
2994 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2995 restSubId := xappConn1.SendRESTSubsReq(t, params)
2996 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
2998 e2termConn1.RecvSubsReq(t)
2999 xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3001 e2termConn1.RecvSubsReq(t)
3002 xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3004 e2termConn1.RecvSubsDelReq(t)
3005 xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3007 xappConn1.ExpectRESTNotification(t, restSubId)
3008 e2termConn1.RecvSubsDelReq(t)
3009 xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3011 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3013 waitSubsCleanup(t, e2SubsId, 10)
3015 mainCtrl.VerifyCounterValues(t)
3019 //-----------------------------------------------------------------------------
3020 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3023 // +-------+ +---------+ +---------+
3024 // | xapp | | submgr | | e2term |
3025 // +-------+ +---------+ +---------+
3028 // |---------------->| |
3030 // | RESTSubResp | |
3031 // |<----------------| |
3033 // | |------------->|
3037 // | |------------->|
3040 // | |------------->|
3044 // | |------------->|
3048 // | |<-------------|
3051 // |<----------------| |
3053 // | [SUBS DELETE] |
3056 //-----------------------------------------------------------------------------
3057 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
3058 CaseBegin("TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr start")
3060 // Init counter check
3061 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3062 Counter{cRestSubReqFromXapp, 1},
3063 Counter{cRestSubRespToXapp, 1},
3064 Counter{cSubReqToE2, 1},
3065 Counter{cSubReReqToE2, 1},
3066 Counter{cSubReqTimerExpiry, 2},
3067 Counter{cSubDelReqToE2, 1},
3068 Counter{cSubDelReReqToE2, 1},
3069 Counter{cSubDelReqTimerExpiry, 2},
3072 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3073 restSubId := xappConn1.SendRESTSubsReq(t, params)
3074 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
3076 e2termConn1.RecvSubsReq(t)
3077 xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3079 e2termConn1.RecvSubsReq(t)
3080 xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3082 e2termConn1.RecvSubsDelReq(t)
3083 xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3085 xappConn1.ExpectRESTNotification(t, restSubId)
3086 e2termConn1.RecvSubsDelReq(t)
3087 xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3089 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3091 waitSubsCleanup(t, e2SubsId, 10)
3093 mainCtrl.VerifyCounterValues(t)
3096 //-----------------------------------------------------------------------------
3097 // TestRESTSubReqSubFailRespInSubmgr
3100 // +-------+ +---------+ +---------+
3101 // | xapp | | submgr | | e2term |
3102 // +-------+ +---------+ +---------+
3105 // |---------------->| |
3107 // | RESTSubResp | |
3108 // |<----------------| |
3110 // | |------------->|
3113 // | |<-------------|
3116 // | |------------->|
3119 // | |<-------------|
3123 // |<----------------| |
3125 // | [SUBS DELETE] |
3128 //-----------------------------------------------------------------------------
3129 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
3130 CaseBegin("TestRESTSubReqSubFailRespInSubmgr")
3132 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3133 Counter{cRestSubReqFromXapp, 1},
3134 Counter{cRestSubRespToXapp, 1},
3135 Counter{cSubReqToE2, 1},
3136 Counter{cSubFailFromE2, 1},
3137 Counter{cRestSubFailNotifToXapp, 1},
3138 Counter{cRestSubDelReqFromXapp, 1},
3141 const subReqCount int = 1
3143 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3144 restSubId := xappConn1.SendRESTSubsReq(t, params)
3146 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3147 fparams1 := &teststube2ap.E2StubSubsFailParams{}
3148 fparams1.Set(crereq1)
3149 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3151 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3152 xappConn1.ExpectRESTNotification(t, restSubId)
3153 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3154 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3155 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
3157 // REST subscription sill there to be deleted
3158 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3160 // Wait that subs is cleaned
3161 waitSubsCleanup(t, e2SubsId, 10)
3163 mainCtrl.VerifyCounterValues(t)
3167 //-----------------------------------------------------------------------------
3168 // TestRESTSubDelReqRetryInSubmgr
3171 // +-------+ +---------+ +---------+
3172 // | xapp | | submgr | | e2term |
3173 // +-------+ +---------+ +---------+
3175 // | [SUBS CREATE] |
3178 // | RESTSubDelReq | |
3179 // |---------------->| |
3181 // | RESTSubDelResp | |
3182 // |<----------------| |
3184 // | |------------->|
3187 // | |------------->|
3190 // | |<-------------|
3193 //-----------------------------------------------------------------------------
3194 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
3195 CaseBegin("TestRESTSubDelReqRetryInSubmgr")
3197 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3198 Counter{cRestSubReqFromXapp, 1},
3199 Counter{cRestSubRespToXapp, 1},
3200 Counter{cSubReqToE2, 1},
3201 Counter{cSubRespFromE2, 1},
3202 Counter{cRestSubNotifToXapp, 1},
3203 Counter{cRestSubDelReqFromXapp, 1},
3204 Counter{cSubDelReqToE2, 1},
3205 Counter{cSubDelReReqToE2, 1},
3206 Counter{cSubDelRespFromE2, 1},
3207 Counter{cRestSubDelRespToXapp, 1},
3210 var params *teststube2ap.RESTSubsReqParams = nil
3211 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3214 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3216 // E2t: Receive 1st SubsDelReq
3217 e2termConn1.RecvSubsDelReq(t)
3219 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
3220 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3221 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3223 //Wait that subs is cleaned
3224 waitSubsCleanup(t, e2SubsId, 10)
3226 mainCtrl.VerifyCounterValues(t)
3229 //-----------------------------------------------------------------------------
3230 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
3233 // +-------+ +---------+ +---------+
3234 // | xapp | | submgr | | e2term |
3235 // +-------+ +---------+ +---------+
3237 // | [SUBS CREATE] |
3240 // | RESTSubDelReq | |
3241 // |---------------->| |
3243 // | RESTSubDelResp | |
3244 // |<----------------| |
3246 // | |------------->|
3249 // | |------------->|
3253 //-----------------------------------------------------------------------------
3254 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
3255 CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr")
3257 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3258 Counter{cRestSubReqFromXapp, 1},
3259 Counter{cRestSubRespToXapp, 1},
3260 Counter{cSubReqToE2, 1},
3261 Counter{cSubRespFromE2, 1},
3262 Counter{cRestSubNotifToXapp, 1},
3263 Counter{cRestSubDelReqFromXapp, 1},
3264 Counter{cSubDelReqToE2, 1},
3265 Counter{cSubDelReReqToE2, 1},
3266 Counter{cSubDelRespFromE2, 1},
3267 Counter{cRestSubDelRespToXapp, 1},
3271 var params *teststube2ap.RESTSubsReqParams = nil
3272 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3275 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3277 // E2t: Receive 1st SubsDelReq
3278 e2termConn1.RecvSubsDelReq(t)
3280 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
3281 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3282 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3284 //Wait that subs is cleaned
3285 waitSubsCleanup(t, e2SubsId, 10)
3287 mainCtrl.VerifyCounterValues(t)
3290 //-----------------------------------------------------------------------------
3291 // TestRESTSubDelReqSubDelFailRespInSubmgr
3294 // +-------+ +---------+ +---------+
3295 // | xapp | | submgr | | e2term |
3296 // +-------+ +---------+ +---------+
3298 // | [SUBS CREATE] |
3301 // | RESTSubDelReq | |
3302 // |---------------->| |
3304 // | RESTSubDelResp | |
3305 // |<----------------| |
3307 // | |------------->|
3310 // | |<-------------|
3313 //-----------------------------------------------------------------------------
3314 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
3315 CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr")
3317 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3318 Counter{cRestSubReqFromXapp, 1},
3319 Counter{cRestSubRespToXapp, 1},
3320 Counter{cSubReqToE2, 1},
3321 Counter{cSubRespFromE2, 1},
3322 Counter{cRestSubNotifToXapp, 1},
3323 Counter{cRestSubDelReqFromXapp, 1},
3324 Counter{cSubDelReqToE2, 1},
3325 Counter{cSubDelFailFromE2, 1},
3326 Counter{cRestSubDelRespToXapp, 1},
3330 var params *teststube2ap.RESTSubsReqParams = nil
3331 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3334 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3336 // E2t: Send receive SubsDelReq and send SubsDelFail
3337 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3338 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
3340 //Wait that subs is cleaned
3341 waitSubsCleanup(t, e2SubsId, 10)
3343 mainCtrl.VerifyCounterValues(t)
3346 //-----------------------------------------------------------------------------
3347 // TestRESTSubReqAndSubDelOkSameAction
3350 // +-------+ +-------+ +---------+ +---------+
3351 // | xapp2 | | xapp1 | | submgr | | e2term |
3352 // +-------+ +-------+ +---------+ +---------+
3354 // | | RESTSubReq1 | |
3355 // | |---------------->| |
3357 // | | RESTSubResp1 | |
3358 // | |<----------------| |
3361 // | | |------------->|
3363 // | | |<-------------|
3364 // | | RESTNotif1 | |
3365 // | |<----------------| |
3367 // | RESTSubReq2 | |
3368 // |------------------------------>| |
3370 // | RESTSubResp2 | |
3371 // |<------------------------------| |
3373 // | | RESTNotif2 | |
3374 // |<------------------------------| |
3376 // | | RESTSubDelReq1 | |
3377 // | |---------------->| |
3379 // | | RESTSubDelResp1 | |
3380 // | |<----------------| |
3382 // | RESTSubDelReq2 | |
3383 // |------------------------------>| |
3385 // | RESTSubDelResp2 | |
3386 // |<------------------------------| |
3388 // | | | SubDelReq2 |
3389 // | | |------------->|
3391 // | | | SubDelResp2 |
3392 // | | |<-------------|
3395 //-----------------------------------------------------------------------------
3396 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
3397 CaseBegin("TestRESTSubReqAndSubDelOkSameAction")
3399 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3400 Counter{cRestSubReqFromXapp, 2},
3401 Counter{cRestSubRespToXapp, 2},
3402 Counter{cSubReqToE2, 1},
3403 Counter{cSubRespFromE2, 1},
3404 Counter{cRestSubNotifToXapp, 2},
3405 Counter{cMergedSubscriptions, 1},
3406 Counter{cUnmergedSubscriptions, 1},
3407 Counter{cRestSubDelReqFromXapp, 2},
3408 Counter{cSubDelReqToE2, 1},
3409 Counter{cSubDelRespFromE2, 1},
3410 Counter{cRestSubDelRespToXapp, 2},
3414 var params *teststube2ap.RESTSubsReqParams = nil
3417 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3418 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
3421 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3422 params.SetMeid("RAN_NAME_1")
3424 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
3425 xappConn2.WaitRESTNotificationForAnySubscriptionId(t)
3426 waiter := rtmgrHttp.AllocNextSleep(10, true)
3427 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3428 waiter.WaitResult(t)
3429 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
3430 e2SubsId2 := <-xappConn2.RESTNotification
3431 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
3433 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
3436 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3439 deleteXapp2Subscription(t, &restSubId2)
3441 //Wait that subs is cleaned
3442 waitSubsCleanup(t, e2SubsId2, 10)
3444 mainCtrl.VerifyCounterValues(t)
3447 //-----------------------------------------------------------------------------
3448 // TestSubReqAndSubDelOkSameActionParallel
3451 // +-------+ +-------+ +---------+ +---------+
3452 // | xapp2 | | xapp1 | | submgr | | e2term |
3453 // +-------+ +-------+ +---------+ +---------+
3458 // | |------------->| |
3461 // | | |------------->|
3463 // |--------------------------->| |
3465 // | | |<-------------|
3467 // | |<-------------| |
3469 // | | |------------->|
3472 // | | |<-------------|
3474 // |<---------------------------| |
3476 // | | SubDelReq 1 | |
3477 // | |------------->| |
3479 // | | SubDelResp 1 | |
3480 // | |<-------------| |
3482 // | SubDelReq 2 | |
3483 // |--------------------------->| |
3485 // | | | SubDelReq 2 |
3486 // | | |------------->|
3488 // | | | SubDelReq 2 |
3489 // | | |------------->|
3491 // | SubDelResp 2 | |
3492 // |<---------------------------| |
3494 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
3495 CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel")
3497 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3498 Counter{cRestSubReqFromXapp, 2},
3499 Counter{cRestSubRespToXapp, 2},
3500 Counter{cSubReqToE2, 2},
3501 Counter{cSubRespFromE2, 2},
3502 Counter{cRestSubNotifToXapp, 2},
3503 Counter{cRestSubDelReqFromXapp, 2},
3504 Counter{cSubDelReqToE2, 2},
3505 Counter{cSubDelRespFromE2, 2},
3506 Counter{cRestSubDelRespToXapp, 2},
3509 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3510 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3511 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3513 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
3514 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
3516 xappConn1.ExpectRESTNotification(t, restSubId1)
3517 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3518 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
3520 xappConn2.ExpectRESTNotification(t, restSubId2)
3521 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3522 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3523 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
3526 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3527 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3528 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3529 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3532 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
3533 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
3534 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
3536 waitSubsCleanup(t, e2SubsId2, 10)
3538 mainCtrl.VerifyCounterValues(t)
3541 //-----------------------------------------------------------------------------
3542 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
3545 // +-------+ +-------+ +---------+ +---------+
3546 // | xapp2 | | xapp1 | | submgr | | e2term |
3547 // +-------+ +-------+ +---------+ +---------+
3551 // | | RESTSubReq1 | |
3552 // | |---------------->| |
3554 // | | RESTSubResp1 | |
3555 // | |<----------------| |
3557 // | | |------------->|
3558 // | RESTSubReq2 | |
3559 // |------------------------------>| |
3561 // | RESTSubDelResp2 | |
3562 // |<------------------------------| |
3564 // | | |------------->|
3567 // | | | SubDelReq |
3568 // | | |------------->|
3570 // | | | SubDelResp |
3571 // | | |<-------------|
3572 // | | RESTNotif1 | |
3573 // | | unsuccess | |
3574 // | |<----------------| |
3576 // | | unsuccess | |
3577 // |<------------------------------| |
3579 // | | RESTSubDelReq1 | |
3580 // | |---------------->| |
3582 // | | RESTSubDelResp1 | |
3583 // | |<----------------| |
3585 // | RESTSubDelReq2 | |
3586 // |------------------------------>| |
3588 // | RESTSubDelResp2 | |
3589 // |<------------------------------| |
3591 //-----------------------------------------------------------------------------
3592 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
3593 CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
3595 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3596 Counter{cRestSubReqFromXapp, 2},
3597 Counter{cRestSubRespToXapp, 2},
3598 Counter{cSubReqToE2, 1},
3599 Counter{cRestSubFailNotifToXapp, 2},
3600 Counter{cRestSubDelReqFromXapp, 2},
3601 Counter{cSubDelReqToE2, 1},
3602 Counter{cSubDelRespFromE2, 1},
3603 Counter{cRestSubDelRespToXapp, 2},
3606 const subReqCount int = 1
3609 params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3610 restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
3611 crereq1, _ := e2termConn1.RecvSubsReq(t)
3614 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
3615 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
3616 params2.SetMeid("RAN_NAME_1")
3617 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
3618 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
3620 //Req1 (retransmitted)
3621 e2termConn1.RecvSubsReq(t)
3623 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3625 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3626 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3628 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3629 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3630 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3631 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3634 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3637 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
3639 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
3641 //Wait that subs is cleaned
3642 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
3644 mainCtrl.VerifyCounterValues(t)
3647 //-----------------------------------------------------------------------------
3648 // TestRESTSubReqAndSubDelNokSameActionParallel
3651 // +-------+ +-------+ +---------+ +---------+
3652 // | xapp2 | | xapp1 | | submgr | | e2term |
3653 // +-------+ +-------+ +---------+ +---------+
3657 // | | RESTSubReq1 | |
3658 // | |---------------->| |
3660 // | | RESTSubResp1 | |
3661 // | |<----------------| |
3663 // | | |------------->|
3664 // | RESTSubReq2 | |
3665 // |------------------------------>| |
3667 // | RESTSubDelResp2 | |
3668 // |<------------------------------| |
3670 // | | |<-------------|
3672 // | | RESTNotif1 | |
3673 // | | unsuccess | |
3674 // | |<----------------| |
3676 // | | unsuccess | |
3677 // |<------------------------------| |
3678 // | | | SubDelReq |
3679 // | | |------------->|
3680 // | | | SubDelResp |
3681 // | | |<-------------|
3683 // | | RESTSubDelReq1 | |
3684 // | |---------------->| |
3686 // | | RESTSubDelResp1 | |
3687 // | |<----------------| |
3689 // | RESTSubDelReq2 | |
3690 // |------------------------------>| |
3692 // | RESTSubDelResp2 | |
3693 // |<------------------------------| |
3695 //-----------------------------------------------------------------------------
3696 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
3697 CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
3699 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3700 Counter{cRestSubReqFromXapp, 2},
3701 Counter{cRestSubRespToXapp, 2},
3702 Counter{cSubReqToE2, 1},
3703 Counter{cSubFailFromE2, 1},
3704 Counter{cRestSubFailNotifToXapp, 2},
3705 Counter{cRestSubDelReqFromXapp, 2},
3706 Counter{cSubDelReqToE2, 1},
3707 Counter{cSubDelRespFromE2, 1},
3708 Counter{cRestSubDelRespToXapp, 2},
3711 const subReqCount int = 1
3714 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3715 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3716 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3719 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
3720 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
3721 params2.SetMeid("RAN_NAME_1")
3722 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
3723 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
3725 // E2t: send SubsFail (first)
3726 fparams1 := &teststube2ap.E2StubSubsFailParams{}
3727 fparams1.Set(crereq1)
3728 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3730 // E2t: internal delete
3731 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3732 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3733 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3735 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3736 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3737 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3738 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3741 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3744 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
3746 //Wait that subs is cleaned
3747 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
3748 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
3750 mainCtrl.VerifyCounterValues(t)
3753 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
3754 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
3756 // Init counter check
3757 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3758 Counter{cRestSubReqFromXapp, 1},
3759 Counter{cRestSubRespToXapp, 1},
3760 Counter{cSubReqToE2, 1},
3761 Counter{cSubRespFromE2, 1},
3762 Counter{cRestSubNotifToXapp, 1},
3763 Counter{cRestSubDelReqFromXapp, 1},
3764 Counter{cSubDelReqToE2, 1},
3765 Counter{cSubDelRespFromE2, 1},
3766 Counter{cRestSubDelRespToXapp, 1},
3769 const subReqCount int = 1
3771 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
3772 restSubId := xappConn1.SendRESTSubsReq(t, params)
3773 xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
3775 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3776 xappConn1.ExpectRESTNotification(t, restSubId)
3777 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3778 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3779 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
3781 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3782 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3783 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3785 // Wait that subs is cleaned
3786 waitSubsCleanup(t, e2SubsId, 10)
3787 mainCtrl.VerifyCounterValues(t)
3790 //-----------------------------------------------------------------------------
3791 // TestRESTSubReqPolicyChangeAndSubDelOk
3794 // +-------+ +---------+ +---------+
3795 // | xapp | | submgr | | e2term |
3796 // +-------+ +---------+ +---------+
3799 // |---------------->| |
3801 // | RESTSubResp | |
3802 // |<----------------| |
3804 // | |------------->|
3807 // | |<-------------|
3810 // |<----------------| |
3813 // |---------------->| |
3815 // | RESTSubResp | |
3816 // |<----------------| |
3818 // | |------------->|
3821 // | |<-------------|
3824 // |<----------------| |
3826 // | RESTSubDelReq | |
3827 // |---------------->| |
3830 // | |------------->|
3833 // | |<-------------|
3835 // | RESTSubDelResp | |
3836 // |<----------------| |
3838 //-----------------------------------------------------------------------------
3839 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
3840 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
3842 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3843 Counter{cRestSubReqFromXapp, 2},
3844 Counter{cRestSubRespToXapp, 2},
3845 Counter{cSubReqToE2, 2},
3846 Counter{cSubRespFromE2, 2},
3847 Counter{cRestSubNotifToXapp, 2},
3848 Counter{cRestSubDelReqFromXapp, 1},
3849 Counter{cSubDelReqToE2, 1},
3850 Counter{cSubDelRespFromE2, 1},
3851 Counter{cRestSubDelRespToXapp, 1},
3854 const subReqCount int = 1
3857 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
3858 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3861 // GetRESTSubsReqPolicyParams sets some coutners on tc side.
3863 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
3864 params.SetSubscriptionID(&restSubId)
3865 params.SetTimeToWait("w200ms")
3866 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
3869 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3871 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3872 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3874 // Wait that subs is cleaned
3875 waitSubsCleanup(t, e2SubsId, 10)
3876 mainCtrl.VerifyCounterValues(t)
3879 //-----------------------------------------------------------------------------
3880 // TestRESTSubReqPolicyChangeNOk
3883 // +-------+ +---------+ +---------+
3884 // | xapp | | submgr | | e2term |
3885 // +-------+ +---------+ +---------+
3888 // |---------------->| |
3890 // | RESTSubResp | |
3891 // |<----------------| |
3893 // | |------------->|
3896 // | |<-------------|
3899 // |<----------------| |
3902 // |---------------->| |
3904 // | RESTSubUpdateFail |
3906 // | RESTSubDelReq | |
3907 // |---------------->| |
3910 // | |------------->|
3913 // | |<-------------|
3915 // | RESTSubDelResp | |
3916 // |<----------------| |
3918 //-----------------------------------------------------------------------------
3919 func TestRESTSubReqPolicyChangeNOk(t *testing.T) {
3920 CaseBegin("TestRESTSubReqPolicyChangeNOk")
3922 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3923 Counter{cRestSubReqFromXapp, 2},
3924 Counter{cRestSubRespToXapp, 1},
3925 Counter{cSubReqToE2, 1},
3926 Counter{cSubRespFromE2, 1},
3927 Counter{cRestSubNotifToXapp, 1},
3928 Counter{cRestSubFailToXapp, 1},
3929 Counter{cRestSubDelReqFromXapp, 1},
3930 Counter{cSubDelReqToE2, 1},
3931 Counter{cSubDelRespFromE2, 1},
3932 Counter{cRestSubDelRespToXapp, 1},
3935 const subReqCount int = 1
3938 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
3939 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3943 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
3945 restSubIdUpd := strings.ToUpper(restSubId)
3946 params.SetSubscriptionID(&restSubIdUpd)
3947 params.SetTimeToWait("w200ms")
3949 restSubId2 := xappConn1.SendRESTSubsReq(t, params)
3950 assert.Equal(t, restSubId2, "")
3953 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3955 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3956 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3958 // Wait that subs is cleaned
3959 waitSubsCleanup(t, e2SubsId, 10)
3960 mainCtrl.VerifyCounterValues(t)
3963 //-----------------------------------------------------------------------------
3964 // TestRESTSubReqAndSubDelOkTwoE2termParallel
3967 // +-------+ +---------+ +---------+ +---------+
3968 // | xapp | | submgr | | e2term1 | | e2term2 |
3969 // +-------+ +---------+ +---------+ +---------+
3973 // | RESTSubReq1 | | |
3974 // |---------------->| | |
3976 // | RESTSubResp1 | | |
3977 // |<----------------| | |
3979 // | |------------->| |
3981 // | RESTSubReq2 | | |
3982 // |---------------->| | |
3984 // | RESTSubResp2 | | |
3985 // |<----------------| | |
3987 // | |---------------------------->|
3990 // | |<-------------| |
3991 // | RESTNotif1 | | |
3992 // |<----------------| | |
3994 // | |<----------------------------|
3995 // | RESTNotif2 | | |
3996 // |<----------------| | |
3998 // | [SUBS 1 DELETE] | |
4000 // | [SUBS 2 DELETE] | |
4003 //-----------------------------------------------------------------------------
4004 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
4005 CaseBegin("TestRESTSubReqAndSubDelOkTwoE2termParallel")
4007 // Init counter check
4008 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4009 Counter{cRestSubReqFromXapp, 2},
4010 Counter{cRestSubRespToXapp, 2},
4011 Counter{cSubReqToE2, 2},
4012 Counter{cSubRespFromE2, 2},
4013 Counter{cRestSubNotifToXapp, 2},
4014 Counter{cRestSubDelReqFromXapp, 2},
4015 Counter{cSubDelReqToE2, 2},
4016 Counter{cSubDelRespFromE2, 2},
4017 Counter{cRestSubDelRespToXapp, 2},
4020 const subReqCount int = 1
4023 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4024 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4025 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4028 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4029 params.SetMeid("RAN_NAME_11")
4030 // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
4031 // would not work as notification would not be received
4032 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4033 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
4036 xappConn1.ExpectRESTNotification(t, restSubId1)
4037 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4038 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4039 xapp.Logger.Info("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
4042 xappConn2.ExpectRESTNotification(t, restSubId2)
4043 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
4044 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4045 xapp.Logger.Info("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
4048 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4049 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4050 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4052 // Wait that subs is cleaned
4053 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4056 xappConn1.SendRESTSubsDelReq(t, &restSubId2)
4057 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
4058 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
4060 // Wait that subs is cleaned
4061 waitSubsCleanup(t, e2SubsId2, 10)
4063 mainCtrl.VerifyCounterValues(t)
4066 //-----------------------------------------------------------------------------
4067 // TestRESTSubReqAsn1EncodeFail
4069 // In this case submgr send RICSubscriptionDeleteRequest after encode failure which should not happen!
4071 // +-------+ +---------+ +---------+
4072 // | xapp | | submgr | | e2term |
4073 // +-------+ +---------+ +---------+
4076 // |---------------->| |
4078 // | RESTSubResp | |
4079 // |<----------------| |
4080 // | RESTSubDelReq | |
4081 // |---------------->| |
4082 // | RESTSubDelResp | |
4084 // |<----------------| |
4087 //-----------------------------------------------------------------------------
4088 func TestRESTSubReqAsn1EncodeFail(t *testing.T) {
4089 CaseBegin("TestRESTSubReqAsn1EncodeFail")
4091 xapp.Logger.Info("Xapp-frame, v0.8.1 sufficient REST API validation")
4095 //-----------------------------------------------------------------------------
4096 // TestRESTSubReqInsertAndSubDelOk
4099 // +-------+ +---------+ +---------+
4100 // | xapp | | submgr | | e2term |
4101 // +-------+ +---------+ +---------+
4104 // |---------------->| |
4106 // | RESTSubResp | |
4107 // |<----------------| |
4110 // | |------------->|
4113 // | |<-------------|
4115 // |<----------------| |
4118 // | RESTSubDelReq | |
4119 // |---------------->| |
4122 // | |------------->|
4125 // | |<-------------|
4127 // | RESTSubDelResp| |
4128 // |<----------------| |
4130 //-----------------------------------------------------------------------------
4131 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
4132 CaseBegin("TestRESTInsertSubReqAndSubDelOk")
4134 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4135 Counter{cRestSubReqFromXapp, 1},
4136 Counter{cRestSubRespToXapp, 1},
4137 Counter{cSubReqToE2, 1},
4138 Counter{cSubRespFromE2, 1},
4139 Counter{cRestSubNotifToXapp, 1},
4140 Counter{cRestSubDelReqFromXapp, 1},
4141 Counter{cSubDelReqToE2, 1},
4142 Counter{cSubDelRespFromE2, 1},
4143 Counter{cRestSubDelRespToXapp, 1},
4146 const subReqCount int = 1
4148 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4149 params.SetSubActionTypes("insert")
4152 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4155 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4157 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4158 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4160 // Wait that subs is cleaned
4161 waitSubsCleanup(t, e2SubsId, 10)
4162 mainCtrl.VerifyCounterValues(t)
4165 //-----------------------------------------------------------------------------
4166 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
4169 // +-------+ +---------+ +---------+
4170 // | xapp | | submgr | | e2term |
4171 // +-------+ +---------+ +---------+
4174 // |------------->| |
4177 // | |------------->|
4182 // | Submgr restart |
4186 // | |------------->|
4189 // | |<-------------|
4192 //-----------------------------------------------------------------------------
4193 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
4194 CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle")
4196 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4197 Counter{cRestSubReqFromXapp, 1},
4198 Counter{cRestSubRespToXapp, 1},
4199 Counter{cSubReqToE2, 1},
4200 Counter{cSubDelReqFromXapp, 1},
4201 Counter{cSubDelReqToE2, 1},
4202 Counter{cSubDelRespFromE2, 1},
4205 const subReqCount int = 1
4207 // Remove possible existing subscription
4208 mainCtrl.removeExistingSubscriptions(t)
4210 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4213 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
4214 restSubId := xappConn1.SendRESTSubsReq(t, params)
4215 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
4217 e2termConn1.RecvSubsReq(t)
4219 mainCtrl.SetResetTestFlag(t, false)
4221 mainCtrl.SimulateRestart(t)
4222 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4225 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4226 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4228 xappConn1.TestMsgChanEmpty(t)
4229 xappConn2.TestMsgChanEmpty(t)
4230 e2termConn1.TestMsgChanEmpty(t)
4231 mainCtrl.wait_registry_empty(t, 10)
4233 mainCtrl.VerifyCounterValues(t)
4236 //-----------------------------------------------------------------------------
4237 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
4240 // +-------+ +---------+ +---------+
4241 // | xapp | | submgr | | e2term |
4242 // +-------+ +---------+ +---------+
4245 // |---------------->| |
4247 // | RESTSubResp | |
4248 // |<----------------| |
4250 // | |------------->|
4253 // | |<-------------|
4256 // |<----------------| |
4259 // | Submgr restart |
4261 // | RESTSubDelReq | |
4262 // |---------------->| |
4265 // | |------------->|
4268 // | |<-------------|
4270 // | RESTSubDelResp | |
4271 // |<----------------| |
4273 //-----------------------------------------------------------------------------
4274 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
4275 CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle")
4277 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4278 Counter{cRestSubReqFromXapp, 1},
4279 Counter{cRestSubRespToXapp, 1},
4280 Counter{cSubReqToE2, 1},
4281 Counter{cSubRespFromE2, 1},
4282 Counter{cRestSubNotifToXapp, 1},
4283 Counter{cRestSubDelReqFromXapp, 1},
4284 Counter{cSubDelReqToE2, 1},
4285 Counter{cRestSubDelRespToXapp, 1},
4288 // Remove possible existing subscription
4289 mainCtrl.removeExistingSubscriptions(t)
4291 var params *teststube2ap.RESTSubsReqParams = nil
4293 // Create subscription
4294 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4295 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
4297 // Check subscription
4298 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4300 // When SDL support for the REST Interface is added
4301 // the submgr restart statement below should be removed
4302 // from the comment.
4304 // mainCtrl.SimulateRestart(t)
4305 // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4307 // Check subscription
4308 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4310 // Delete subscription
4311 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
4313 //Wait that subs is cleaned
4314 waitSubsCleanup(t, e2SubsId, 10)
4316 mainCtrl.VerifyCounterValues(t)
4319 //-----------------------------------------------------------------------------
4320 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
4323 // +-------+ +-------+ +---------+ +---------+
4324 // | xapp2 | | xapp1 | | submgr | | e2term |
4325 // +-------+ +-------+ +---------+ +---------+
4327 // | | RESTSubReq1 | |
4328 // | |---------------->| |
4330 // | | RESTSubResp1 | |
4331 // | |<----------------| |
4334 // | | |------------->|
4336 // | | |<-------------|
4337 // | | RESTNotif1 | |
4338 // | |<----------------| |
4340 // | RESTSubReq2 | |
4341 // |------------------------------>| |
4343 // | RESTSubResp2 | |
4344 // |<------------------------------| |
4346 // | | RESTNotif2 | |
4347 // |<------------------------------| |
4349 // | | Submgr restart |
4351 // | | RESTSubDelReq1 | |
4352 // | |---------------->| |
4354 // | | RESTSubDelResp1 | |
4355 // | |<----------------| |
4357 // | | Submgr restart |
4359 // | RESTSubDelReq2 | |
4360 // |------------------------------>| |
4362 // | RESTSubDelResp2 | |
4363 // |<------------------------------| |
4365 // | | | SubDelReq2 |
4366 // | | |------------->|
4368 // | | | SubDelResp2 |
4369 // | | |<-------------|
4372 //-----------------------------------------------------------------------------
4373 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
4374 CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
4376 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4377 Counter{cRestSubReqFromXapp, 2},
4378 Counter{cRestSubRespToXapp, 2},
4379 Counter{cSubReqToE2, 1},
4380 Counter{cSubRespFromE2, 1},
4381 Counter{cRestSubNotifToXapp, 2},
4382 Counter{cMergedSubscriptions, 1},
4383 Counter{cUnmergedSubscriptions, 1},
4384 Counter{cRestSubDelReqFromXapp, 2},
4385 Counter{cSubDelReqToE2, 1},
4386 Counter{cSubDelRespFromE2, 1},
4387 Counter{cRestSubDelRespToXapp, 2},
4390 // Remove possible existing subscription
4391 mainCtrl.removeExistingSubscriptions(t)
4393 var params *teststube2ap.RESTSubsReqParams = nil
4395 // Create subscription 1
4396 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4397 xapp.Logger.Info("Send REST subscriber request for subscriber 1 : %v", restSubId1)
4399 // Create subscription 2 with same action
4400 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4401 params.SetMeid("RAN_NAME_1")
4402 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4403 xappConn2.WaitRESTNotificationForAnySubscriptionId(t)
4404 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4405 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4406 e2SubsId2 := <-xappConn2.RESTNotification
4407 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
4409 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
4411 // When SDL support for the REST Interface is added
4412 // the submgr restart statement below should be removed
4413 // from the comment.
4415 // mainCtrl.SimulateRestart(t)
4416 // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4418 // Delete subscription 1, and wait until it has removed the first endpoint
4419 subepcnt := mainCtrl.get_subs_entrypoint_cnt(t, e2SubsId1)
4420 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4421 mainCtrl.wait_subs_entrypoint_cnt_change(t, e2SubsId1, subepcnt, 10)
4423 // When SDL support for the REST Interface is added
4424 // the submgr restart statement below should be removed
4425 // from the comment.
4427 // mainCtrl.SimulateRestart(t)
4428 // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4429 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
4431 // Delete subscription 2
4432 deleteXapp2Subscription(t, &restSubId2)
4434 //Wait that subs is cleaned
4435 waitSubsCleanup(t, e2SubsId2, 10)
4437 mainCtrl.VerifyCounterValues(t)
4440 //-----------------------------------------------------------------------------
4441 // TestRESTReportSubReqAndSubDelOk
4444 // +-------+ +---------+ +---------+
4445 // | xapp | | submgr | | e2term |
4446 // +-------+ +---------+ +---------+
4449 // |---------------->| |
4451 // | RESTSubResp | |
4452 // |<----------------| |
4455 // | |------------->|
4458 // | |<-------------|
4460 // |<----------------| |
4462 // | |------------->|
4465 // | |<-------------|
4467 // |<----------------| |
4471 // | RESTSubDelReq | |
4472 // |---------------->| |
4475 // | |------------->|
4478 // | |<-------------|
4480 // | RESTSubDelResp| |
4481 // |<----------------| |
4483 //-----------------------------------------------------------------------------
4484 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
4485 CaseBegin("TestRESTReportSubReqAndSubDelOk")
4488 RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
4491 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
4492 xapp.Logger.Info("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
4495 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4496 restSubId := xappConn1.SendRESTSubsReq(t, params)
4498 var e2SubsId []uint32
4499 for i := 0; i < subReqCount; i++ {
4500 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4501 xappConn1.ExpectRESTNotification(t, restSubId)
4503 e2termConn1.SendSubsResp(t, crereq, cremsg)
4504 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
4505 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
4506 e2SubsId = append(e2SubsId, instanceId)
4507 resp, _ := xapp.Subscription.QuerySubscriptions()
4508 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
4509 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
4510 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
4515 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4517 for i := 0; i < subReqCount; i++ {
4518 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4519 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4522 // Wait that subs is cleaned
4523 for i := 0; i < subReqCount; i++ {
4524 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
4527 xappConn1.TestMsgChanEmpty(t)
4528 e2termConn1.TestMsgChanEmpty(t)
4529 mainCtrl.wait_registry_empty(t, 10)
4533 func TestRESTPolicySubReqAndSubDelOk(t *testing.T) {
4534 CaseBegin("TestRESTPolicySubReqAndSubDelOk")
4538 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
4542 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
4545 func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
4546 xapp.Logger.Info("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
4549 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4550 restSubId := xappConn1.SendRESTSubsReq(t, params)
4551 //params := xappConn1.GetRESTSubsReqPolicyParams1(subReqCount)
4552 //restSubId := xappConn1.SendRESTPolicySubsReq(t, params)
4554 var e2SubsId []uint32
4555 for i := 0; i < subReqCount; i++ {
4556 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4557 xappConn1.ExpectRESTNotification(t, restSubId)
4558 e2termConn1.SendSubsResp(t, crereq, cremsg)
4559 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
4560 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
4561 e2SubsId = append(e2SubsId, instanceId)
4565 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4567 for i := 0; i < subReqCount; i++ {
4568 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4569 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4572 // Wait that subs is cleaned
4573 for i := 0; i < subReqCount; i++ {
4574 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
4576 xappConn1.TestMsgChanEmpty(t)
4577 e2termConn1.TestMsgChanEmpty(t)
4578 mainCtrl.wait_registry_empty(t, 10)
4581 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
4585 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4586 Counter{cRestSubReqFromXapp, 1},
4587 Counter{cRestSubRespToXapp, 1},
4588 Counter{cSubReqToE2, 2},
4589 Counter{cSubRespFromE2, 2},
4590 Counter{cRestSubNotifToXapp, 2},
4591 Counter{cRestSubDelReqFromXapp, 1},
4592 Counter{cSubDelReqToE2, 2},
4593 Counter{cSubDelRespFromE2, 2},
4594 Counter{cRestSubDelRespToXapp, 1},
4598 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4599 restSubId := xappConn1.SendRESTSubsReq(t, params)
4600 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4602 assert.Equal(t, len(e2SubsIds), 2)
4605 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4606 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4608 xappConn1.TestMsgChanEmpty(t)
4609 e2termConn1.TestMsgChanEmpty(t)
4610 mainCtrl.wait_registry_empty(t, 10)
4612 mainCtrl.VerifyCounterValues(t)
4614 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
4618 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4619 Counter{cRestSubReqFromXapp, 1},
4620 Counter{cRestSubRespToXapp, 1},
4621 Counter{cSubReqToE2, 19},
4622 Counter{cSubRespFromE2, 19},
4623 Counter{cRestSubNotifToXapp, 19},
4624 Counter{cRestSubDelReqFromXapp, 1},
4625 Counter{cSubDelReqToE2, 19},
4626 Counter{cSubDelRespFromE2, 19},
4627 Counter{cRestSubDelRespToXapp, 1},
4631 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4632 restSubId := xappConn1.SendRESTSubsReq(t, params)
4633 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4635 assert.Equal(t, len(e2SubsIds), 19)
4637 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4638 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4640 xappConn1.TestMsgChanEmpty(t)
4641 e2termConn1.TestMsgChanEmpty(t)
4642 mainCtrl.wait_registry_empty(t, 10)
4644 mainCtrl.VerifyCounterValues(t)
4646 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
4650 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4651 Counter{cRestSubReqFromXapp, 1},
4652 Counter{cRestSubRespToXapp, 1},
4653 Counter{cSubReqToE2, uint64(subReqCount)},
4654 Counter{cSubRespFromE2, uint64(subReqCount)},
4655 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
4656 Counter{cRestSubDelReqFromXapp, 1},
4657 Counter{cSubDelReqToE2, uint64(subReqCount)},
4658 Counter{cSubDelRespFromE2, uint64(subReqCount)},
4659 Counter{cRestSubDelRespToXapp, 1},
4663 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4664 restSubId := xappConn1.SendRESTSubsReq(t, params)
4665 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4667 assert.Equal(t, len(e2SubsIds), subReqCount)
4670 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4671 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4673 xappConn1.TestMsgChanEmpty(t)
4674 e2termConn1.TestMsgChanEmpty(t)
4675 mainCtrl.wait_registry_empty(t, 10)
4677 mainCtrl.VerifyCounterValues(t)
4680 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
4684 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4685 Counter{cRestSubReqFromXapp, 1},
4686 Counter{cRestSubRespToXapp, 1},
4687 Counter{cSubReqToE2, uint64(subReqCount)},
4688 Counter{cSubRespFromE2, uint64(subReqCount)},
4689 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
4690 Counter{cRestSubDelReqFromXapp, 1},
4691 Counter{cSubDelReqToE2, uint64(subReqCount)},
4692 Counter{cSubDelRespFromE2, uint64(subReqCount)},
4693 Counter{cRestSubDelRespToXapp, 1},
4697 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4698 restSubId := xappConn1.SendRESTSubsReq(t, params)
4699 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4701 assert.Equal(t, len(e2SubsIds), subReqCount)
4704 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4705 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4707 xappConn1.TestMsgChanEmpty(t)
4708 e2termConn1.TestMsgChanEmpty(t)
4709 mainCtrl.wait_registry_empty(t, 10)
4711 mainCtrl.VerifyCounterValues(t)
4714 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
4718 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4719 Counter{cRestSubReqFromXapp, 1},
4720 Counter{cRestSubRespToXapp, 1},
4721 Counter{cSubReqToE2, uint64(subReqCount)},
4722 Counter{cSubRespFromE2, uint64(subReqCount)},
4723 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
4724 Counter{cRestSubDelReqFromXapp, 1},
4725 Counter{cSubDelReqToE2, uint64(subReqCount)},
4726 Counter{cSubDelRespFromE2, uint64(subReqCount)},
4727 Counter{cRestSubDelRespToXapp, 1},
4731 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4732 restSubId := xappConn1.SendRESTSubsReq(t, params)
4733 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4735 assert.Equal(t, len(e2SubsIds), subReqCount)
4738 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4739 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4741 xappConn1.TestMsgChanEmpty(t)
4742 e2termConn1.TestMsgChanEmpty(t)
4743 mainCtrl.wait_registry_empty(t, 10)
4745 mainCtrl.VerifyCounterValues(t)
4748 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
4749 CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
4751 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4752 Counter{cRestSubReqFromXapp, 2},
4753 Counter{cRestSubRespToXapp, 2},
4754 Counter{cSubReqToE2, 2},
4755 Counter{cSubRespFromE2, 2},
4756 Counter{cRestSubNotifToXapp, 2},
4757 Counter{cRestSubDelReqFromXapp, 2},
4758 Counter{cSubDelReqToE2, 2},
4759 Counter{cSubDelRespFromE2, 2},
4760 Counter{cRestSubDelRespToXapp, 2},
4764 var params *teststube2ap.RESTSubsReqParams = nil
4767 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4768 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4770 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4773 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4774 params.SetMeid("RAN_NAME_1")
4775 eventTriggerDefinition := []int64{1234, 1}
4776 params.SetSubEventTriggerDefinition(eventTriggerDefinition)
4778 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4779 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4780 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4781 xappConn2.ExpectRESTNotification(t, restSubId2)
4782 e2termConn1.SendSubsResp(t, crereq, cremsg)
4783 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4785 deleteXapp1Subscription(t, &restSubId1)
4786 deleteXapp2Subscription(t, &restSubId2)
4788 waitSubsCleanup(t, e2SubsId1, 10)
4789 waitSubsCleanup(t, e2SubsId2, 10)
4791 mainCtrl.VerifyCounterValues(t)
4795 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
4796 CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
4798 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4799 Counter{cRestSubReqFromXapp, 2},
4800 Counter{cRestSubRespToXapp, 2},
4801 Counter{cSubReqToE2, 2},
4802 Counter{cSubRespFromE2, 2},
4803 Counter{cRestSubNotifToXapp, 2},
4804 Counter{cRestSubDelReqFromXapp, 2},
4805 Counter{cSubDelReqToE2, 2},
4806 Counter{cSubDelRespFromE2, 2},
4807 Counter{cRestSubDelRespToXapp, 2},
4811 var params *teststube2ap.RESTSubsReqParams = nil
4814 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4815 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4817 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4820 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4821 params.SetMeid("RAN_NAME_1")
4823 actionId := int64(1)
4824 actionType := "report"
4825 actionDefinition := []int64{5678, 1}
4826 subsequestActionType := "continue"
4827 timeToWait := "w10ms"
4828 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
4830 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4831 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4832 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4833 xappConn2.ExpectRESTNotification(t, restSubId2)
4834 e2termConn1.SendSubsResp(t, crereq, cremsg)
4835 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4837 deleteXapp1Subscription(t, &restSubId1)
4838 deleteXapp2Subscription(t, &restSubId2)
4840 waitSubsCleanup(t, e2SubsId1, 10)
4841 waitSubsCleanup(t, e2SubsId2, 10)
4843 mainCtrl.VerifyCounterValues(t)
4847 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
4848 CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
4850 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4851 Counter{cRestSubReqFromXapp, 2},
4852 Counter{cRestSubRespToXapp, 2},
4853 Counter{cSubReqToE2, 2},
4854 Counter{cSubRespFromE2, 2},
4855 Counter{cRestSubNotifToXapp, 2},
4856 Counter{cRestSubDelReqFromXapp, 2},
4857 Counter{cSubDelReqToE2, 2},
4858 Counter{cSubDelRespFromE2, 2},
4859 Counter{cRestSubDelRespToXapp, 2},
4863 var params *teststube2ap.RESTSubsReqParams = nil
4866 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4867 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4869 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4872 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4873 params.SetMeid("RAN_NAME_1")
4874 params.SetSubActionIDs(int64(2))
4876 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4877 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4878 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4879 xappConn2.ExpectRESTNotification(t, restSubId2)
4880 e2termConn1.SendSubsResp(t, crereq, cremsg)
4881 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4883 deleteXapp1Subscription(t, &restSubId1)
4884 deleteXapp2Subscription(t, &restSubId2)
4886 waitSubsCleanup(t, e2SubsId1, 10)
4887 waitSubsCleanup(t, e2SubsId2, 10)
4889 mainCtrl.VerifyCounterValues(t)
4893 func TestRESTSubReqDiffActionType(t *testing.T) {
4894 CaseBegin("TestRESTSubReqDiffActionType")
4896 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4897 Counter{cRestSubReqFromXapp, 2},
4898 Counter{cRestSubRespToXapp, 2},
4899 Counter{cSubReqToE2, 2},
4900 Counter{cSubRespFromE2, 2},
4901 Counter{cRestSubNotifToXapp, 2},
4902 Counter{cRestSubDelReqFromXapp, 2},
4903 Counter{cSubDelReqToE2, 2},
4904 Counter{cSubDelRespFromE2, 2},
4905 Counter{cRestSubDelRespToXapp, 2},
4909 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4912 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4913 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4915 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4918 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4919 params.SetMeid("RAN_NAME_1")
4921 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4922 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4923 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4924 xappConn2.ExpectRESTNotification(t, restSubId2)
4925 e2termConn1.SendSubsResp(t, crereq, cremsg)
4926 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4928 deleteXapp1Subscription(t, &restSubId1)
4929 deleteXapp2Subscription(t, &restSubId2)
4931 waitSubsCleanup(t, e2SubsId1, 10)
4932 waitSubsCleanup(t, e2SubsId2, 10)
4934 mainCtrl.VerifyCounterValues(t)
4938 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
4939 CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
4941 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4942 Counter{cRestSubReqFromXapp, 2},
4943 Counter{cRestSubRespToXapp, 2},
4944 Counter{cSubReqToE2, 2},
4945 Counter{cSubRespFromE2, 2},
4946 Counter{cRestSubNotifToXapp, 2},
4947 Counter{cRestSubDelReqFromXapp, 2},
4948 Counter{cSubDelReqToE2, 2},
4949 Counter{cSubDelRespFromE2, 2},
4950 Counter{cRestSubDelRespToXapp, 2},
4954 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4957 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4958 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4960 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4963 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
4964 params.SetMeid("RAN_NAME_1")
4966 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4967 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4968 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4969 xappConn2.ExpectRESTNotification(t, restSubId2)
4970 e2termConn1.SendSubsResp(t, crereq, cremsg)
4971 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4973 deleteXapp1Subscription(t, &restSubId1)
4974 deleteXapp2Subscription(t, &restSubId2)
4976 waitSubsCleanup(t, e2SubsId1, 10)
4977 waitSubsCleanup(t, e2SubsId2, 10)
4979 mainCtrl.VerifyCounterValues(t)
4983 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
4984 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
4986 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4987 Counter{cRestSubReqFromXapp, 2},
4988 Counter{cRestSubRespToXapp, 2},
4989 Counter{cSubReqToE2, 2},
4990 Counter{cSubRespFromE2, 2},
4991 Counter{cRestSubNotifToXapp, 2},
4992 Counter{cRestSubDelReqFromXapp, 2},
4993 Counter{cSubDelReqToE2, 2},
4994 Counter{cSubDelRespFromE2, 2},
4995 Counter{cRestSubDelRespToXapp, 2},
4999 var params *teststube2ap.RESTSubsReqParams = nil
5002 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5003 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5005 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5008 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5009 params.SetMeid("RAN_NAME_1")
5010 actionDefinition := []int64{5678, 1}
5011 params.SetSubActionDefinition(actionDefinition)
5013 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5014 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5015 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5016 xappConn2.ExpectRESTNotification(t, restSubId2)
5017 e2termConn1.SendSubsResp(t, crereq, cremsg)
5018 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5020 deleteXapp1Subscription(t, &restSubId1)
5021 deleteXapp2Subscription(t, &restSubId2)
5023 waitSubsCleanup(t, e2SubsId1, 10)
5024 waitSubsCleanup(t, e2SubsId2, 10)
5026 mainCtrl.VerifyCounterValues(t)
5030 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
5031 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
5033 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5034 Counter{cRestSubReqFromXapp, 2},
5035 Counter{cRestSubRespToXapp, 2},
5036 Counter{cSubReqToE2, 2},
5037 Counter{cSubRespFromE2, 2},
5038 Counter{cRestSubNotifToXapp, 2},
5039 Counter{cRestSubDelReqFromXapp, 2},
5040 Counter{cSubDelReqToE2, 2},
5041 Counter{cSubDelRespFromE2, 2},
5042 Counter{cRestSubDelRespToXapp, 2},
5046 var params *teststube2ap.RESTSubsReqParams = nil
5049 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5050 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5052 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5055 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5056 params.SetMeid("RAN_NAME_1")
5057 actionDefinition := []int64{56782}
5058 params.SetSubActionDefinition(actionDefinition)
5060 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5061 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5062 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5063 xappConn2.ExpectRESTNotification(t, restSubId2)
5064 e2termConn1.SendSubsResp(t, crereq, cremsg)
5065 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5067 deleteXapp1Subscription(t, &restSubId1)
5068 deleteXapp2Subscription(t, &restSubId2)
5070 waitSubsCleanup(t, e2SubsId1, 10)
5071 waitSubsCleanup(t, e2SubsId2, 10)
5073 mainCtrl.VerifyCounterValues(t)
5077 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
5078 CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
5080 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5081 Counter{cRestSubReqFromXapp, 2},
5082 Counter{cRestSubRespToXapp, 2},
5083 Counter{cSubReqToE2, 2},
5084 Counter{cSubRespFromE2, 2},
5085 Counter{cRestSubNotifToXapp, 2},
5086 Counter{cRestSubDelReqFromXapp, 2},
5087 Counter{cSubDelReqToE2, 2},
5088 Counter{cSubDelRespFromE2, 2},
5089 Counter{cRestSubDelRespToXapp, 2},
5093 var params *teststube2ap.RESTSubsReqParams = nil
5096 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5097 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5099 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5102 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5103 params.SetMeid("RAN_NAME_1")
5104 params.SetTimeToWait("w200ms")
5105 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5106 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5107 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5108 xappConn2.ExpectRESTNotification(t, restSubId2)
5109 e2termConn1.SendSubsResp(t, crereq, cremsg)
5110 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5112 deleteXapp1Subscription(t, &restSubId1)
5113 deleteXapp2Subscription(t, &restSubId2)
5115 waitSubsCleanup(t, e2SubsId1, 10)
5116 waitSubsCleanup(t, e2SubsId2, 10)
5118 mainCtrl.VerifyCounterValues(t)
5122 //-----------------------------------------------------------------------------
5123 // TestRESTUnpackSubscriptionResponseDecodeFail
5126 // +-------+ +---------+ +---------+
5127 // | xapp | | submgr | | e2term |
5128 // +-------+ +---------+ +---------+
5131 // |---------------->| |
5133 // | RESTSubResp | |
5134 // |<----------------| |
5137 // | |------------->|
5139 // | | SubResp | ASN.1 decode fails
5140 // | |<-------------|
5143 // | |------------->|
5145 // | | SubFail | Duplicated action
5146 // | |<-------------|
5147 // | RESTNotif (fail)| |
5148 // |<----------------| |
5150 // | |------------->|
5153 // | |<-------------|
5155 //-----------------------------------------------------------------------------
5156 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
5157 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
5161 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5162 restSubId := xappConn1.SendRESTSubsReq(t, params)
5164 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5165 // Decode of this response fails which will result resending original request
5166 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
5168 _, cremsg = e2termConn1.RecvSubsReq(t)
5170 xappConn1.ExpectRESTNotification(t, restSubId)
5172 // Subscription already created in E2 Node.
5173 fparams := &teststube2ap.E2StubSubsFailParams{}
5175 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5176 e2termConn1.SendSubsFail(t, fparams, cremsg)
5178 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5179 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5181 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5182 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5184 // Wait that subs is cleaned
5185 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5187 xappConn1.TestMsgChanEmpty(t)
5188 e2termConn1.TestMsgChanEmpty(t)
5189 mainCtrl.wait_registry_empty(t, 10)
5192 //-----------------------------------------------------------------------------
5193 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
5196 // +-------+ +---------+ +---------+
5197 // | xapp | | submgr | | e2term |
5198 // +-------+ +---------+ +---------+
5201 // |---------------->| |
5203 // | RESTSubResp | |
5204 // |<----------------| |
5207 // | |------------->|
5209 // | | SubResp | Unknown instanceId
5210 // | |<-------------|
5213 // | |------------->|
5215 // | | SubFail | Duplicated action
5216 // | |<-------------|
5217 // | RESTNotif (fail)| |
5218 // |<----------------| |
5220 // | |------------->|
5223 // | |<-------------|
5225 //-----------------------------------------------------------------------------
5226 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
5227 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
5231 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5232 restSubId := xappConn1.SendRESTSubsReq(t, params)
5234 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5236 // Unknown instanceId in this response which will result resending original request
5237 orgInstanceId := crereq.RequestId.InstanceId
5238 crereq.RequestId.InstanceId = 0
5239 e2termConn1.SendSubsResp(t, crereq, cremsg)
5241 _, cremsg = e2termConn1.RecvSubsReq(t)
5243 xappConn1.ExpectRESTNotification(t, restSubId)
5245 // Subscription already created in E2 Node.
5246 fparams := &teststube2ap.E2StubSubsFailParams{}
5248 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5249 e2termConn1.SendSubsFail(t, fparams, cremsg)
5251 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5252 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5254 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5255 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5257 // Wait that subs is cleaned
5258 mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
5260 xappConn1.TestMsgChanEmpty(t)
5261 e2termConn1.TestMsgChanEmpty(t)
5262 mainCtrl.wait_registry_empty(t, 10)
5265 //-----------------------------------------------------------------------------
5266 // TestRESTUnpackSubscriptionResponseNoTransaction
5269 // +-------+ +---------+ +---------+
5270 // | xapp | | submgr | | e2term |
5271 // +-------+ +---------+ +---------+
5274 // |---------------->| |
5276 // | RESTSubResp | |
5277 // |<----------------| |
5280 // | |------------->|
5282 // | | SubResp | No transaction for the response
5283 // | |<-------------|
5286 // | |------------->|
5288 // | | SubFail | Duplicated action
5289 // | |<-------------|
5290 // | RESTNotif (fail)| |
5291 // |<----------------| |
5293 // | |------------->|
5296 // | |<-------------|
5299 // | |------------->|
5302 // | |<-------------|
5304 //-----------------------------------------------------------------------------
5305 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
5306 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
5310 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5311 restSubId := xappConn1.SendRESTSubsReq(t, params)
5313 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5315 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
5316 // No transaction exist for this response which will result resending original request
5317 e2termConn1.SendSubsResp(t, crereq, cremsg)
5319 _, cremsg = e2termConn1.RecvSubsReq(t)
5321 xappConn1.ExpectRESTNotification(t, restSubId)
5323 // Subscription already created in E2 Node.
5324 fparams := &teststube2ap.E2StubSubsFailParams{}
5326 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5327 e2termConn1.SendSubsFail(t, fparams, cremsg)
5329 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5330 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5332 // Resending happens because there no transaction
5333 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5334 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5336 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5337 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5339 // Wait that subs is cleaned
5340 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5342 xappConn1.TestMsgChanEmpty(t)
5343 e2termConn1.TestMsgChanEmpty(t)
5344 mainCtrl.wait_registry_empty(t, 10)
5348 //-----------------------------------------------------------------------------
5349 // TestRESTUnpackSubscriptionFailureDecodeFail
5352 // +-------+ +---------+ +---------+
5353 // | xapp | | submgr | | e2term |
5354 // +-------+ +---------+ +---------+
5357 // |---------------->| |
5359 // | RESTSubResp | |
5360 // |<----------------| |
5363 // | |------------->|
5365 // | | SubFail | ASN.1 decode fails
5366 // | |<-------------|
5369 // | |------------->|
5371 // | | SubFail | Duplicated action
5372 // | |<-------------|
5373 // | RESTNotif (fail)| |
5374 // |<----------------| |
5376 // | |------------->|
5379 // | |<-------------|
5381 //-----------------------------------------------------------------------------
5382 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
5383 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
5387 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5388 restSubId := xappConn1.SendRESTSubsReq(t, params)
5390 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5392 // Decode of this response fails which will result resending original request
5393 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
5395 _, cremsg = e2termConn1.RecvSubsReq(t)
5397 xappConn1.ExpectRESTNotification(t, restSubId)
5399 // Subscription already created in E2 Node.
5400 fparams := &teststube2ap.E2StubSubsFailParams{}
5402 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5403 e2termConn1.SendSubsFail(t, fparams, cremsg)
5405 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5406 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5408 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5409 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5411 // Wait that subs is cleaned
5412 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5414 xappConn1.TestMsgChanEmpty(t)
5415 e2termConn1.TestMsgChanEmpty(t)
5416 mainCtrl.wait_registry_empty(t, 10)
5419 //-----------------------------------------------------------------------------
5420 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
5423 // +-------+ +---------+ +---------+
5424 // | xapp | | submgr | | e2term |
5425 // +-------+ +---------+ +---------+
5428 // |---------------->| |
5430 // | RESTSubResp | |
5431 // |<----------------| |
5434 // | |------------->|
5436 // | | SubFail | Unknown instanceId
5437 // | |<-------------|
5440 // | |------------->|
5442 // | | SubFail | Duplicated action
5443 // | |<-------------|
5444 // | RESTNotif (fail)| |
5445 // |<----------------| |
5447 // | |------------->|
5450 // | |<-------------|
5452 //-----------------------------------------------------------------------------
5453 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
5454 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
5458 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5459 restSubId := xappConn1.SendRESTSubsReq(t, params)
5461 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5463 // Unknown instanceId in this response which will result resending original request
5464 fparams := &teststube2ap.E2StubSubsFailParams{}
5466 fparams.Fail.RequestId.InstanceId = 0
5467 e2termConn1.SendSubsFail(t, fparams, cremsg)
5469 _, cremsg = e2termConn1.RecvSubsReq(t)
5471 xappConn1.ExpectRESTNotification(t, restSubId)
5473 // Subscription already created in E2 Node.
5474 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5475 e2termConn1.SendSubsFail(t, fparams, cremsg)
5477 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5478 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5480 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5481 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5483 // Wait that subs is cleaned
5484 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5486 xappConn1.TestMsgChanEmpty(t)
5487 e2termConn1.TestMsgChanEmpty(t)
5488 mainCtrl.wait_registry_empty(t, 10)
5491 //-----------------------------------------------------------------------------
5492 // TestRESTUnpackSubscriptionFailureNoTransaction
5495 // +-------+ +---------+ +---------+
5496 // | xapp | | submgr | | e2term |
5497 // +-------+ +---------+ +---------+
5500 // |---------------->| |
5502 // | RESTSubResp | |
5503 // |<----------------| |
5506 // | |------------->|
5508 // | | SubFail | No transaction for the response
5509 // | |<-------------|
5512 // | |------------->|
5514 // | | SubFail | Duplicated action
5515 // | |<-------------|
5516 // | RESTNotif (fail)| |
5517 // |<----------------| |
5519 // | |------------->|
5522 // | |<-------------|
5524 //-----------------------------------------------------------------------------
5525 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
5526 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
5530 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5531 restSubId := xappConn1.SendRESTSubsReq(t, params)
5533 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5535 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
5537 // No transaction exist for this response which will result resending original request
5538 fparams := &teststube2ap.E2StubSubsFailParams{}
5540 e2termConn1.SendSubsFail(t, fparams, cremsg)
5542 _, cremsg = e2termConn1.RecvSubsReq(t)
5544 xappConn1.ExpectRESTNotification(t, restSubId)
5546 // Subscription already created in E2 Node.
5547 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5548 e2termConn1.SendSubsFail(t, fparams, cremsg)
5550 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5551 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5553 // Resending happens because there no transaction
5554 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5555 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5557 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5558 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5560 // Wait that subs is cleaned
5561 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5563 xappConn1.TestMsgChanEmpty(t)
5564 e2termConn1.TestMsgChanEmpty(t)
5565 mainCtrl.wait_registry_empty(t, 10)
5568 //-----------------------------------------------------------------------------
5569 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
5572 // +-------+ +---------+ +---------+
5573 // | xapp | | submgr | | e2term |
5574 // +-------+ +---------+ +---------+
5576 // | [SUBS CREATE] |
5579 // | RESTSubDelReq | |
5580 // |---------------->| |
5582 // | RESTSubDelResp | |
5583 // |<----------------| |
5586 // | |------------->|
5588 // | | SubDelResp | ASN.1 decode fails
5589 // | |<-------------|
5592 // | |------------->|
5594 // | | SubDelFail | Subscription does exist any more
5595 // | |<-------------|
5598 //-----------------------------------------------------------------------------
5599 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
5600 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail")
5603 var params *teststube2ap.RESTSubsReqParams = nil
5604 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5607 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5609 // E2t: Receive 1st SubsDelReq
5610 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5612 // Decode of this response fails which will result resending original request
5613 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_REQ)
5615 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
5616 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5618 // Subscription does not exist in in E2 Node.
5619 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5621 // Wait that subs is cleaned
5622 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5624 xappConn1.TestMsgChanEmpty(t)
5625 e2termConn1.TestMsgChanEmpty(t)
5626 mainCtrl.wait_registry_empty(t, 10)
5629 //-----------------------------------------------------------------------------
5630 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
5633 // +-------+ +---------+ +---------+
5634 // | xapp | | submgr | | e2term |
5635 // +-------+ +---------+ +---------+
5637 // | [SUBS CREATE] |
5640 // | RESTSubDelReq | |
5641 // |---------------->| |
5643 // | RESTSubDelResp | |
5644 // |<----------------| |
5647 // | |------------->|
5649 // | | SubDelResp | Unknown instanceId
5650 // | |<-------------|
5653 // | |------------->|
5655 // | | SubDelFail | Subscription does exist any more
5656 // | |<-------------|
5658 //-----------------------------------------------------------------------------
5659 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
5660 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId")
5663 var params *teststube2ap.RESTSubsReqParams = nil
5664 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5667 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5669 // E2t: Receive 1st SubsDelReq
5670 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5672 // Unknown instanceId in this response which will result resending original request
5673 delreq.RequestId.InstanceId = 0
5674 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5676 // E2t: Receive 2nd SubsDelReq
5677 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5679 // Subscription does not exist in in E2 Node.
5680 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5682 // Wait that subs is cleaned
5683 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5685 xappConn1.TestMsgChanEmpty(t)
5686 e2termConn1.TestMsgChanEmpty(t)
5687 mainCtrl.wait_registry_empty(t, 10)
5690 //-----------------------------------------------------------------------------
5691 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
5694 // +-------+ +---------+ +---------+
5695 // | xapp | | submgr | | e2term |
5696 // +-------+ +---------+ +---------+
5698 // | [SUBS CREATE] |
5701 // | RESTSubDelReq | |
5702 // |---------------->| |
5704 // | RESTSubDelResp | |
5705 // |<----------------| |
5708 // | |------------->|
5710 // | | SubDelResp | No transaction for the response
5711 // | |<-------------|
5714 // | |------------->|
5716 // | | SubDelFail | Subscription does exist any more
5717 // | |<-------------|
5719 //-----------------------------------------------------------------------------
5720 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
5721 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction")
5724 var params *teststube2ap.RESTSubsReqParams = nil
5725 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5728 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5730 // E2t: Receive 1st SubsDelReq
5731 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5733 mainCtrl.MakeTransactionNil(t, e2SubsId)
5735 // No transaction exist for this response which will result resending original request
5736 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5738 // E2t: Receive 2nd SubsDelReq
5739 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5741 // Subscription does not exist in in E2 Node.
5742 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5744 // Wait that subs is cleaned
5745 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5747 xappConn1.TestMsgChanEmpty(t)
5748 e2termConn1.TestMsgChanEmpty(t)
5749 mainCtrl.wait_registry_empty(t, 10)
5752 //-----------------------------------------------------------------------------
5753 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
5756 // +-------+ +---------+ +---------+
5757 // | xapp | | submgr | | e2term |
5758 // +-------+ +---------+ +---------+
5760 // | [SUBS CREATE] |
5763 // | RESTSubDelReq | |
5764 // |---------------->| |
5766 // | RESTSubDelResp | |
5767 // |<----------------| |
5770 // | |------------->|
5772 // | | SubDelFail | ASN.1 decode fails
5773 // | |<-------------|
5776 // | |------------->|
5778 // | | SubDelFail | Subscription does exist any more
5779 // | |<-------------|
5781 //-----------------------------------------------------------------------------
5782 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
5783 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail")
5786 var params *teststube2ap.RESTSubsReqParams = nil
5787 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5790 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5792 // E2t: Receive 1st SubsDelReq
5793 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5795 // Decode of this response fails which will result resending original request
5796 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
5798 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
5799 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5801 // Subscription does not exist in in E2 Node.
5802 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5804 // Wait that subs is cleaned
5805 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5807 xappConn1.TestMsgChanEmpty(t)
5808 e2termConn1.TestMsgChanEmpty(t)
5809 mainCtrl.wait_registry_empty(t, 10)
5812 //-----------------------------------------------------------------------------
5813 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
5816 // +-------+ +---------+ +---------+
5817 // | xapp | | submgr | | e2term |
5818 // +-------+ +---------+ +---------+
5820 // | [SUBS CREATE] |
5823 // | RESTSubDelReq | |
5824 // |---------------->| |
5826 // | RESTSubDelResp | |
5827 // |<----------------| |
5830 // | |------------->|
5832 // | | SubDelFail | Unknown instanceId
5833 // | |<-------------|
5836 // | |------------->|
5838 // | | SubDelFail | Subscription does exist any more
5839 // | |<-------------|
5841 //-----------------------------------------------------------------------------
5842 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
5843 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId")
5846 var params *teststube2ap.RESTSubsReqParams = nil
5847 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5850 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5852 // E2t: Receive 1st SubsDelReq
5853 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5855 // Unknown instanceId in this response which will result resending original request
5856 delreq.RequestId.InstanceId = 0
5857 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5859 // E2t: Receive 2nd SubsDelReq
5860 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5862 // Subscription does not exist in in E2 Node.
5863 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5865 // Wait that subs is cleaned
5866 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5868 xappConn1.TestMsgChanEmpty(t)
5869 e2termConn1.TestMsgChanEmpty(t)
5870 mainCtrl.wait_registry_empty(t, 10)
5873 //-----------------------------------------------------------------------------
5874 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
5877 // +-------+ +---------+ +---------+
5878 // | xapp | | submgr | | e2term |
5879 // +-------+ +---------+ +---------+
5881 // | [SUBS CREATE] |
5884 // | RESTSubDelReq | |
5885 // |---------------->| |
5887 // | RESTSubDelResp | |
5888 // |<----------------| |
5891 // | |------------->|
5893 // | | SubDelFail | No transaction for the response
5894 // | |<-------------|
5897 // | |------------->|
5899 // | | SubDelFail | Subscription does exist any more
5900 // | |<-------------|
5902 //-----------------------------------------------------------------------------
5903 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
5904 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction")
5907 var params *teststube2ap.RESTSubsReqParams = nil
5908 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5911 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5913 // E2t: Receive 1st SubsDelReq
5914 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5916 mainCtrl.MakeTransactionNil(t, e2SubsId)
5918 // No transaction exist for this response which will result resending original request
5919 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5921 // E2t: Receive 2nd SubsDelReq
5922 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5924 // Subscription does not exist in in E2 Node.
5925 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5927 // Wait that subs is cleaned
5928 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5930 xappConn1.TestMsgChanEmpty(t)
5931 e2termConn1.TestMsgChanEmpty(t)
5932 mainCtrl.wait_registry_empty(t, 10)
5935 //-----------------------------------------------------------------------------
5936 // TestRESTSubReqFailAsn1PackSubReqError
5939 // +-------+ +---------+ +---------+
5940 // | xapp | | submgr | | e2term |
5941 // +-------+ +---------+ +---------+
5944 // |---------------->| |
5946 // | RESTSubResp | |
5947 // |<----------------| |
5949 // | ASN.1 encode fails |
5952 // | |------------->|
5955 // | |<-------------|
5959 // |<----------------| |
5961 // | [SUBS DELETE] |
5964 //-----------------------------------------------------------------------------
5965 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
5967 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5968 Counter{cRestSubReqFromXapp, 1},
5969 Counter{cRestSubRespToXapp, 1},
5970 Counter{cSubDelReqToE2, 1},
5971 Counter{cSubDelFailFromE2, 1},
5972 Counter{cRestSubFailNotifToXapp, 1},
5977 var params *teststube2ap.RESTSubsReqParams = nil
5978 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
5979 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
5982 restSubId := xappConn1.SendRESTSubsReq(t, params)
5983 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
5985 // E2t: Receive SubsDelReq
5986 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5987 xappConn1.ExpectRESTNotification(t, restSubId)
5989 // Subscription does not exist in in E2 Node.
5990 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5992 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
5993 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
5995 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
5996 // Wait that subs is cleaned
5997 waitSubsCleanup(t, e2SubsId, 10)
5998 mainCtrl.VerifyCounterValues(t)
6001 ////////////////////////////////////////////////////////////////////////////////////
6002 // Services for UT cases
6003 ////////////////////////////////////////////////////////////////////////////////////
6004 const subReqCount int = 1
6005 const host string = "localhost"
6007 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
6009 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
6011 restSubId := fromXappConn.SendRESTSubsReq(t, params)
6012 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
6014 crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
6015 fromXappConn.ExpectRESTNotification(t, restSubId)
6016 toE2termConn.SendSubsResp(t, crereq1, cremsg1)
6017 e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
6018 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
6020 return restSubId, e2SubsId
6023 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
6025 params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
6027 params.SetMeid(meid)
6029 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
6030 restSubId := xappConn2.SendRESTSubsReq(t, params)
6031 xappConn2.ExpectRESTNotification(t, restSubId)
6032 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
6033 e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
6034 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
6036 return restSubId, e2SubsId
6039 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
6040 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6041 restSubId := xappConn1.SendRESTSubsReq(t, params)
6042 xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
6044 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6045 xappConn1.ExpectRESTNotification(t, restSubId)
6046 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
6047 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6048 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
6050 return restSubId, e2SubsId
6053 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
6054 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6055 restSubId := xappConn1.SendRESTSubsReq(t, params)
6057 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6058 fparams1 := &teststube2ap.E2StubSubsFailParams{}
6059 fparams1.Set(crereq1)
6060 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
6062 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
6063 xappConn1.ExpectRESTNotification(t, restSubId)
6064 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
6065 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6066 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
6068 return restSubId, e2SubsId
6071 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
6072 fromXappConn.SendRESTSubsDelReq(t, restSubId)
6073 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
6074 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
6077 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
6078 xappConn1.SendRESTSubsDelReq(t, restSubId)
6079 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6080 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6083 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
6084 xappConn2.SendRESTSubsDelReq(t, restSubId)
6085 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6086 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6089 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
6090 resp, _ := xapp.Subscription.QuerySubscriptions()
6091 assert.Equal(t, resp[0].SubscriptionID, e2SubsId)
6092 assert.Equal(t, resp[0].Meid, meid)
6093 assert.Equal(t, resp[0].ClientEndpoint, endpoint)
6096 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
6097 //Wait that subs is cleaned
6098 mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
6100 xappConn1.TestMsgChanEmpty(t)
6101 xappConn2.TestMsgChanEmpty(t)
6102 e2termConn1.TestMsgChanEmpty(t)
6103 mainCtrl.wait_registry_empty(t, timeout)
6106 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
6108 var e2SubsId []uint32
6110 for i := 0; i < count; i++ {
6111 xapp.Logger.Info("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
6112 crereq, cremsg := toE2termConn.RecvSubsReq(t)
6113 fromXappConn.ExpectRESTNotification(t, restSubId)
6114 toE2termConn.SendSubsResp(t, crereq, cremsg)
6115 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
6116 e2SubsId = append(e2SubsId, instanceId)
6117 xapp.Logger.Info("TEST: %v", e2SubsId)
6118 xapp.Logger.Info("TEST: %d ===================================== END CRE ============================================", i+1)
6119 <-time.After(100 * time.Millisecond)
6124 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
6126 for i := 0; i < len(e2SubsIds); i++ {
6127 xapp.Logger.Info("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
6128 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
6129 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
6130 <-time.After(1 * time.Second)
6131 xapp.Logger.Info("TEST: %d ===================================== END DEL ============================================", i+1)
6132 <-time.After(100 * time.Millisecond)
6135 // Wait that subs is cleaned
6136 for i := 0; i < len(e2SubsIds); i++ {
6137 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)