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 ==================================================================================
28 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
29 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper"
30 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
31 "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststube2ap"
32 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
33 "github.com/stretchr/testify/assert"
36 func TestSuiteSetup(t *testing.T) {
37 // The effect of this call shall endure though the UT suite!
38 // If this causes any issues, the previous interface can be restored
40 // SetPackerIf(e2ap_wrapper.NewAsn1E2APPacker())
42 SetPackerIf(e2ap_wrapper.NewUtAsn1E2APPacker())
43 mainCtrl.c.restDuplicateCtrl.Init()
46 func TestRanStatusChangeViaSDLNotification(t *testing.T) {
48 // Current UT test cases use these ran names
49 xappRnibMock.CreateGnb("RAN_NAME_1", entities.ConnectionStatus_DISCONNECTED)
50 xappRnibMock.CreateGnb("RAN_NAME_11", entities.ConnectionStatus_DISCONNECTED)
51 xappRnibMock.CreateGnb("RAN_NAME_2", entities.ConnectionStatus_DISCONNECTED)
53 mainCtrl.c.e2IfState.ReadE2ConfigurationFromRnib()
54 mainCtrl.c.e2IfState.SubscribeChannels()
56 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
57 mainCtrl.SetE2State(t, "RAN_NAME_2_CONNECTED")
58 mainCtrl.SetE2State(t, "RAN_NAME_11_CONNECTED")
61 //-----------------------------------------------------------------------------
62 // TestRESTSubReqAfterE2ConnBreak
65 // +-------+ +---------+ +---------+
66 // | xapp | | submgr | | e2term |
67 // +-------+ +---------+ +---------+
69 // | [E2 Conn. DOWN] |
72 // |---------------->| |
74 // |<----------------| |
77 //-----------------------------------------------------------------------------
79 func TestRESTSubReqAfterE2ConnBreak(t *testing.T) {
80 CaseBegin("TestRESTSubReqAfterE2ConnBreak")
82 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
83 Counter{cRestSubReqFromXapp, 1},
84 Counter{cRestReqRejDueE2Down, 1},
87 // E2 disconnect after E2term has received response
88 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
90 const subReqCount int = 1
91 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
92 xappConn1.SendRESTSubsReq(t, params)
94 // Restore E2 connection for following test cases
95 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
97 mainCtrl.VerifyCounterValues(t)
100 //-----------------------------------------------------------------------------
101 // TestRESTSubReqE2ConnBreak
104 // +-------+ +---------+ +---------+
105 // | xapp | | submgr | | e2term |
106 // +-------+ +---------+ +---------+
109 // |---------------->| |
111 // |<----------------| |
113 // | |------------->|
115 // | |<-------------|
117 // | [E2 Conn. DOWN] |
118 // | [Int. SUBS DELETE] |
120 // | RESTNotif(unsuccessful) |
121 // |<----------------| |
125 //-----------------------------------------------------------------------------
126 func TestRESTSubReqE2ConnBreak(t *testing.T) {
127 CaseBegin("TestRESTSubReqE2ConnBreak")
129 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
130 Counter{cRestSubReqFromXapp, 1},
131 Counter{cRestSubRespToXapp, 1},
132 Counter{cSubReqToE2, 1},
133 Counter{cSubRespFromE2, 1},
134 Counter{cRestSubFailNotifToXapp, 1},
138 const subReqCount int = 1
139 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
140 restSubId := xappConn1.SendRESTSubsReq(t, params)
142 crereq, cremsg := e2termConn1.RecvSubsReq(t)
143 xappConn1.ExpectRESTNotification(t, restSubId)
145 // E2 disconnect after E2term has received response
146 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
148 e2termConn1.SendSubsResp(t, crereq, cremsg)
149 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
151 <-time.After(time.Second * 1)
152 assert.Equal(t, 0, len(mainCtrl.c.registry.register))
153 assert.Equal(t, 0, len(mainCtrl.c.registry.restSubscriptions))
155 subIds, register, err := mainCtrl.c.ReadAllSubscriptionsFromSdl()
157 xapp.Logger.Error("%v", err)
159 assert.Equal(t, 65534, len(subIds)) // range 1-65535 , FFFF = 65535
160 assert.Equal(t, 0, len(register))
163 restSubscriptions, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
165 xapp.Logger.Error("%v", err)
167 assert.Equal(t, 0, len(restSubscriptions))
170 // Restore E2 connection for following test cases
171 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
173 // Wait that subs is cleaned
174 waitSubsCleanup(t, e2SubsId, 10)
175 mainCtrl.VerifyCounterValues(t)
178 //-----------------------------------------------------------------------------
179 // TestRESTSubscriptionDeleteAfterE2ConnectionBreak
182 // +-------+ +---------+ +---------+
183 // | xapp | | submgr | | e2term |
184 // +-------+ +---------+ +---------+
188 // | [E2 Conn. DOWN] |
190 // | RESTSubDelReq | |
191 // |---------------->| |
193 // | RESTSubDelResp | |
194 // |<----------------| |
196 // | [No valid subscription found] |
199 //-----------------------------------------------------------------------------
200 func TestRESTSubscriptionDeleteAfterE2ConnectionBreak(t *testing.T) {
201 xapp.Logger.Debug("TEST: TestRESTSubscriptionDeleteAfterE2ConnectionBreak")
203 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
204 Counter{cRestSubReqFromXapp, 1},
205 Counter{cRestSubRespToXapp, 1},
206 Counter{cSubReqToE2, 1},
207 Counter{cSubRespFromE2, 1},
208 Counter{cRestSubNotifToXapp, 1},
209 Counter{cRestSubDelReqFromXapp, 1},
210 Counter{cRestSubDelRespToXapp, 1},
214 var params *teststube2ap.RESTSubsReqParams = nil
215 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
217 // E2 disconnect after E2term has received response
218 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
221 xappConn1.SendRESTSubsDelReq(t, &restSubId)
223 <-time.After(time.Second * 1)
224 assert.Equal(t, 0, len(mainCtrl.c.registry.register))
225 assert.Equal(t, 0, len(mainCtrl.c.registry.restSubscriptions))
227 subIds, register, err := mainCtrl.c.ReadAllSubscriptionsFromSdl()
229 xapp.Logger.Error("%v", err)
231 assert.Equal(t, 65534, len(subIds)) // range 1-65535 , FFFF = 65535
232 assert.Equal(t, 0, len(register))
235 restSubscriptions, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
237 xapp.Logger.Error("%v", err)
239 assert.Equal(t, 0, len(restSubscriptions))
242 // Restore E2 connection for following test cases
243 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
245 // Wait that subs is cleaned
246 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
248 xappConn1.TestMsgChanEmpty(t)
249 e2termConn1.TestMsgChanEmpty(t)
250 mainCtrl.wait_registry_empty(t, 10)
251 mainCtrl.VerifyCounterValues(t)
254 //-----------------------------------------------------------------------------
255 // TestRESTOtherE2ConnectionChanges
259 // +-------+ +---------+ +---------+
260 // | xapp | | submgr | | e2term |
261 // +-------+ +---------+ +---------+
265 // | [E2 CONNECTED_SETUP_FAILED] |
266 // | [E2 CONNECTING] |
267 // | [E2 SHUTTING_DOWN] |
268 // | [E2 SHUT_DOWN] |
273 //-----------------------------------------------------------------------------
274 func TestRESTOtherE2ConnectionChanges(t *testing.T) {
275 xapp.Logger.Debug("TEST: TestRESTOtherE2ConnectionChanges")
277 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
278 Counter{cRestSubReqFromXapp, 1},
279 Counter{cRestSubRespToXapp, 1},
280 Counter{cSubReqToE2, 1},
281 Counter{cSubRespFromE2, 1},
282 Counter{cRestSubNotifToXapp, 1},
283 Counter{cRestSubDelReqFromXapp, 1},
284 Counter{cSubDelReqToE2, 1},
285 Counter{cSubDelRespFromE2, 1},
286 Counter{cRestSubDelRespToXapp, 1},
290 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
291 restSubId := xappConn1.SendRESTSubsReq(t, params)
293 crereq, cremsg := e2termConn1.RecvSubsReq(t)
294 xappConn1.ExpectRESTNotification(t, restSubId)
295 e2termConn1.SendSubsResp(t, crereq, cremsg)
296 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
298 // Submgr should not react any other connection state changes than CONNECTED and DISCONNECTED
299 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED_SETUP_FAILED")
300 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTING")
301 mainCtrl.SetE2State(t, "RAN_NAME_1_SHUTTING_DOWN")
302 mainCtrl.SetE2State(t, "RAN_NAME_1_SHUT_DOWN")
305 xappConn1.SendRESTSubsDelReq(t, &restSubId)
306 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
307 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
309 // Restore E2 connection for following test cases
310 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
312 // Wait that subs is cleaned
313 waitSubsCleanup(t, e2SubsId, 10)
314 mainCtrl.VerifyCounterValues(t)
317 //-----------------------------------------------------------------------------
318 // TestRESTSubReqAndDeleteOkWithE2apUtWrapper
321 // +-------+ +---------+ +---------+ +---------+
322 // | xapp | | submgr | | e2term | | rtmgr |
323 // +-------+ +---------+ +---------+ +---------+
325 // | RESTSubReq | | |
326 // |---------------->| | |
327 // | | RouteCreate | |
328 // | |--------------------------->| // The order of these events may vary
330 // | RESTSubResp | | | // The order of these events may vary
331 // |<----------------| | |
332 // | | RouteResponse| |
333 // | |<---------------------------| // The order of these events may vary
336 // | |------------->| | // The order of these events may vary
339 // | |<-------------| |
340 // | RESTNotif1 | | |
341 // |<----------------| | |
343 // | RESTSubDelReq | | |
344 // |---------------->| | |
346 // | |------------->| |
348 // | RESTSubDelResp| | |
349 // |<----------------| | |
351 // | | SubDelResp | |
352 // | |<-------------| |
356 //-----------------------------------------------------------------------------
357 func TestRESTSubReqAndDeleteOkWithE2apUtWrapper(t *testing.T) {
359 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
361 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
363 waitSubsCleanup(t, e2SubsId, 10)
366 //-----------------------------------------------------------------------------
367 // TestRESTSubReqAndE1apDeleteReqPackingError
370 // +-------+ +---------+ +---------+ +---------+
371 // | xapp | | submgr | | e2term | | rtmgr |
372 // +-------+ +---------+ +---------+ +---------+
374 // | RESTSubReq | | |
375 // |---------------->| | |
376 // | | RouteCreate | |
377 // | |--------------------------->| // The order of these events may vary
379 // | RESTSubResp | | | // The order of these events may vary
380 // |<----------------| | |
381 // | | RouteResponse| |
382 // | |<---------------------------| // The order of these events may vary
385 // | |------------->| | // The order of these events may vary
388 // | |<-------------| |
389 // | RESTNotif1 | | |
390 // |<----------------| | |
392 // | RESTSubDelReq | | |
393 // |---------------->| | |
395 // | RESTSubDelResp| | |
396 // |<----------------| | |
400 //-----------------------------------------------------------------------------
401 func TestRESTSubReqAndE1apDeleteReqPackingError(t *testing.T) {
403 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
405 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, false)
406 xappConn1.SendRESTSubsDelReq(t, &restSubId)
407 defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, true)
409 waitSubsCleanup(t, e2SubsId, 10)
412 //-----------------------------------------------------------------------------
413 // TestRESTSubReqAndE1apDeleteRespUnpackingError
416 // +-------+ +---------+ +---------+ +---------+
417 // | xapp | | submgr | | e2term | | rtmgr |
418 // +-------+ +---------+ +---------+ +---------+
420 // | RESTSubReq | | |
421 // |---------------->| | |
422 // | | RouteCreate | |
423 // | |--------------------------->| // The order of these events may vary
425 // | RESTSubResp | | | // The order of these events may vary
426 // |<----------------| | |
427 // | | RouteResponse| |
428 // | |<---------------------------| // The order of these events may vary
431 // | |------------->| | // The order of these events may vary
434 // | |<-------------| |
435 // | RESTNotif1 | | |
436 // |<----------------| | |
438 // | RESTSubDelReq | | |
439 // |---------------->| | |
441 // | |------------->| |
443 // | RESTSubDelResp| | |
444 // |<----------------| | | // The order of these events may vary
446 // | | SubDelResp | |
447 // | |<-------------| | // 1.st NOK
450 // | |------------->| |
452 // | | SubDelResp | |
453 // | |<-------------| | // 2.nd NOK
455 //-----------------------------------------------------------------------------
457 func TestRESTSubReqAndE1apDeleteRespUnpackingError(t *testing.T) {
459 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
461 xappConn1.SendRESTSubsDelReq(t, &restSubId)
462 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, false)
463 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
464 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
466 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
467 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
469 defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, true)
471 waitSubsCleanup(t, e2SubsId, 10)
474 //-----------------------------------------------------------------------------
475 // TestSubReqAndRouteNok
478 // +-------+ +---------+ +---------+
479 // | xapp | | submgr | | rtmgr |
480 // +-------+ +---------+ +---------+
483 // |------------->| |
486 // | |------------->|
490 // | |<-------------|
492 // | [SUBS INT DELETE] |
495 //-----------------------------------------------------------------------------
497 func TestSubReqAndRouteNok(t *testing.T) {
498 CaseBegin("TestSubReqAndRouteNok")
500 // Init counter check
501 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
502 Counter{cSubReqFromXapp, 1},
503 Counter{cRouteCreateFail, 1},
506 waiter := rtmgrHttp.AllocNextEvent(false)
507 newSubsId := mainCtrl.get_registry_next_subid(t)
508 xappConn1.SendSubsReq(t, nil, nil)
511 //Wait that subs is cleaned
512 mainCtrl.wait_subs_clean(t, newSubsId, 10)
514 xappConn1.TestMsgChanEmpty(t)
515 xappConn2.TestMsgChanEmpty(t)
516 e2termConn1.TestMsgChanEmpty(t)
517 mainCtrl.wait_registry_empty(t, 10)
519 <-time.After(1 * time.Second)
520 mainCtrl.VerifyCounterValues(t)
523 //-----------------------------------------------------------------------------
524 // TestSubReqAndRouteUpdateNok
527 // +-------+ +-------+ +---------+ +---------+
528 // | xapp2 | | xapp1 | | submgr | | rtmgr |
529 // +-------+ +-------+ +---------+ +---------+
531 // | [SUBS CREATE] | |
535 // | SubReq (mergeable) | |
536 // |--------------------------->| | |
538 // | | | RouteUpdate |
539 // | | |------------->|
541 // | | | RouteUpdate |
542 // | | | status:400 |
543 // | | |<-------------|
545 // | [SUBS INT DELETE] | |
548 // | [SUBS DELETE] | |
551 func TestSubReqAndRouteUpdateNok(t *testing.T) {
552 CaseBegin("TestSubReqAndRouteUpdateNok")
554 // Init counter check
555 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
556 Counter{cSubReqFromXapp, 2},
557 Counter{cSubReqToE2, 1},
558 Counter{cSubRespFromE2, 1},
559 Counter{cSubRespToXapp, 1},
560 Counter{cRouteCreateUpdateFail, 1},
561 Counter{cSubDelReqFromXapp, 1},
562 Counter{cSubDelReqToE2, 1},
563 Counter{cSubDelRespFromE2, 1},
564 Counter{cSubDelRespToXapp, 1},
567 cretrans := xappConn1.SendSubsReq(t, nil, nil)
568 crereq, cremsg := e2termConn1.RecvSubsReq(t)
569 e2termConn1.SendSubsResp(t, crereq, cremsg)
570 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
572 resp, _ := xapp.Subscription.QuerySubscriptions()
573 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
574 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
575 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
577 waiter := rtmgrHttp.AllocNextEvent(false)
578 newSubsId := mainCtrl.get_registry_next_subid(t)
579 xappConn2.SendSubsReq(t, nil, nil)
582 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
583 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
585 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
586 xappConn1.RecvSubsDelResp(t, deltrans)
588 //Wait that subs is cleaned
589 mainCtrl.wait_subs_clean(t, newSubsId, 10)
590 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
592 xappConn1.TestMsgChanEmpty(t)
593 xappConn2.TestMsgChanEmpty(t)
594 e2termConn1.TestMsgChanEmpty(t)
595 mainCtrl.wait_registry_empty(t, 10)
597 mainCtrl.VerifyCounterValues(t)
600 //-----------------------------------------------------------------------------
601 // TestSubDelReqAndRouteDeleteNok
604 // +-------+ +---------+ +---------+ +---------+
605 // | xapp | | submgr | | e2term | | rtmgr |
606 // +-------+ +---------+ +---------+ +---------+
608 // | [SUBS CREATE] | |
613 // |------------->| | |
615 // | |------------->| |
617 // | |<-------------| |
619 // |<-------------| | |
620 // | | RouteDelete | |
621 // | |---------------------------->|
623 // | | RouteDelete | |
624 // | | status:400 | |
625 // | |<----------------------------|
627 func TestSubDelReqAndRouteDeleteNok(t *testing.T) {
628 CaseBegin("TestSubDelReqAndRouteDeleteNok")
630 // Init counter check
631 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
632 Counter{cSubReqFromXapp, 1},
633 Counter{cSubReqToE2, 1},
634 Counter{cSubRespFromE2, 1},
635 Counter{cSubRespToXapp, 1},
636 Counter{cSubDelReqFromXapp, 1},
637 Counter{cRouteDeleteFail, 1},
638 Counter{cSubDelReqToE2, 1},
639 Counter{cSubDelRespFromE2, 1},
640 Counter{cSubDelRespToXapp, 1},
643 cretrans := xappConn1.SendSubsReq(t, nil, nil)
644 crereq, cremsg := e2termConn1.RecvSubsReq(t)
645 e2termConn1.SendSubsResp(t, crereq, cremsg)
646 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
648 resp, _ := xapp.Subscription.QuerySubscriptions()
649 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
650 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
651 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
653 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
654 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
656 waiter := rtmgrHttp.AllocNextEvent(false)
657 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
660 xappConn1.RecvSubsDelResp(t, deltrans)
662 //Wait that subs is cleaned
663 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
665 xappConn1.TestMsgChanEmpty(t)
666 xappConn2.TestMsgChanEmpty(t)
667 e2termConn1.TestMsgChanEmpty(t)
668 mainCtrl.wait_registry_empty(t, 10)
670 mainCtrl.VerifyCounterValues(t)
673 //-----------------------------------------------------------------------------
674 // TestSubMergeDelAndRouteUpdateNok
676 // +-------+ +-------+ +---------+ +---------+
677 // | xapp2 | | xapp1 | | submgr | | e2term |
678 // +-------+ +-------+ +---------+ +---------+
683 // | |------------->| |
686 // | | |------------->|
688 // | | |<-------------|
690 // | |<-------------| |
693 // |--------------------------->| |
696 // |<---------------------------| |
698 // | | SubDelReq 1 | |
699 // | |------------->| |
700 // | | | RouteUpdate |
701 // | | |-----> rtmgr |
703 // | | | RouteUpdate |
704 // | | | status:400 |
705 // | | |<----- rtmgr |
707 // | | SubDelResp 1 | |
708 // | |<-------------| |
711 // |--------------------------->| |
713 // | | | SubDelReq 2 |
714 // | | |------------->|
716 // | | | SubDelReq 2 |
717 // | | |------------->|
719 // | SubDelResp 2 | |
720 // |<---------------------------| |
722 //-----------------------------------------------------------------------------
723 func TestSubMergeDelAndRouteUpdateNok(t *testing.T) {
724 CaseBegin("TestSubMergeDelAndRouteUpdateNok")
726 // Init counter check
727 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
728 Counter{cSubReqFromXapp, 2},
729 Counter{cSubReqToE2, 1},
730 Counter{cSubRespFromE2, 1},
731 Counter{cSubRespToXapp, 2},
732 Counter{cSubDelReqFromXapp, 2},
733 Counter{cRouteDeleteUpdateFail, 1},
734 Counter{cSubDelReqToE2, 1},
735 Counter{cSubDelRespFromE2, 1},
736 Counter{cSubDelRespToXapp, 2},
740 rparams1 := &teststube2ap.E2StubSubsReqParams{}
742 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
743 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
744 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
745 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
748 rparams2 := &teststube2ap.E2StubSubsReqParams{}
750 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
751 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
753 resp, _ := xapp.Subscription.QuerySubscriptions()
754 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
755 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
756 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
759 waiter := rtmgrHttp.AllocNextEvent(false)
760 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
763 xappConn1.RecvSubsDelResp(t, deltrans1)
766 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
767 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
768 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
769 xappConn2.RecvSubsDelResp(t, deltrans2)
770 //Wait that subs is cleaned
771 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
773 xappConn1.TestMsgChanEmpty(t)
774 xappConn2.TestMsgChanEmpty(t)
775 e2termConn1.TestMsgChanEmpty(t)
776 mainCtrl.wait_registry_empty(t, 10)
778 mainCtrl.VerifyCounterValues(t)
781 //-----------------------------------------------------------------------------
783 //-----------------------------------------------------------------------------
784 // TestSubReqAndSubDelOk
787 // +-------+ +---------+ +---------+
788 // | xapp | | submgr | | e2term |
789 // +-------+ +---------+ +---------+
792 // |------------->| |
795 // | |------------->|
798 // | |<-------------|
801 // |<-------------| |
805 // |------------->| |
808 // | |------------->|
811 // | |<-------------|
814 // |<-------------| |
816 //-----------------------------------------------------------------------------
817 func TestSubReqAndSubDelOk(t *testing.T) {
818 CaseBegin("TestSubReqAndSubDelOk")
820 // Init counter check
821 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
822 Counter{cSubReqFromXapp, 1},
823 Counter{cSubReqToE2, 1},
824 Counter{cSubRespFromE2, 1},
825 Counter{cSubRespToXapp, 1},
826 Counter{cSubDelReqFromXapp, 1},
827 Counter{cSubDelReqToE2, 1},
828 Counter{cSubDelRespFromE2, 1},
829 Counter{cSubDelRespToXapp, 1},
832 cretrans := xappConn1.SendSubsReq(t, nil, nil)
833 crereq, cremsg := e2termConn1.RecvSubsReq(t)
834 e2termConn1.SendSubsResp(t, crereq, cremsg)
835 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
837 resp, _ := xapp.Subscription.QuerySubscriptions()
838 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
839 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
840 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
842 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
843 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
845 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
846 xappConn1.RecvSubsDelResp(t, deltrans)
848 //Wait that subs is cleaned
849 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
851 xappConn1.TestMsgChanEmpty(t)
852 xappConn2.TestMsgChanEmpty(t)
853 e2termConn1.TestMsgChanEmpty(t)
854 mainCtrl.wait_registry_empty(t, 10)
856 mainCtrl.VerifyCounterValues(t)
859 //-----------------------------------------------------------------------------
860 // TestSubReqRetransmission
863 // +-------+ +---------+ +---------+
864 // | xapp | | submgr | | e2term |
865 // +-------+ +---------+ +---------+
868 // |------------->| |
871 // | |------------->|
875 // |------------->| |
878 // | |<-------------|
881 // |<-------------| |
886 //-----------------------------------------------------------------------------
887 func TestSubReqRetransmission(t *testing.T) {
888 CaseBegin("TestSubReqRetransmission")
891 cretrans := xappConn1.SendSubsReq(t, nil, nil)
892 crereq, cremsg := e2termConn1.RecvSubsReq(t)
894 seqBef := mainCtrl.get_msgcounter(t)
895 xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq
896 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
898 // hack as there is no real way to see has message be handled.
899 // Previuos counter check just tells that is has been received by submgr
900 // --> artificial delay
901 <-time.After(1 * time.Second)
902 e2termConn1.SendSubsResp(t, crereq, cremsg)
903 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
906 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
907 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
908 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
909 xappConn1.RecvSubsDelResp(t, deltrans)
911 //Wait that subs is cleaned
912 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
914 xappConn1.TestMsgChanEmpty(t)
915 xappConn2.TestMsgChanEmpty(t)
916 e2termConn1.TestMsgChanEmpty(t)
917 mainCtrl.wait_registry_empty(t, 10)
920 //-----------------------------------------------------------------------------
921 // TestSubDelReqRetransmission
924 // +-------+ +---------+ +---------+
925 // | xapp | | submgr | | e2term |
926 // +-------+ +---------+ +---------+
932 // |------------->| |
935 // | |------------->|
940 // |------------->| |
943 // | |<-------------|
946 // |<-------------| |
948 //-----------------------------------------------------------------------------
949 func TestSubDelReqRetransmission(t *testing.T) {
950 CaseBegin("TestSubDelReqRetransmission")
953 cretrans := xappConn1.SendSubsReq(t, nil, nil)
954 crereq, cremsg := e2termConn1.RecvSubsReq(t)
955 e2termConn1.SendSubsResp(t, crereq, cremsg)
956 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
959 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
960 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
962 seqBef := mainCtrl.get_msgcounter(t)
963 xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq
964 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
966 // hack as there is no real way to see has message be handled.
967 // Previuos counter check just tells that is has been received by submgr
968 // --> artificial delay
969 <-time.After(1 * time.Second)
971 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
972 xappConn1.RecvSubsDelResp(t, deltrans)
974 //Wait that subs is cleaned
975 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
977 xappConn1.TestMsgChanEmpty(t)
978 xappConn2.TestMsgChanEmpty(t)
979 e2termConn1.TestMsgChanEmpty(t)
980 mainCtrl.wait_registry_empty(t, 10)
983 //-----------------------------------------------------------------------------
984 // TestSubDelReqCollision
987 // +-------+ +---------+ +---------+
988 // | xapp | | submgr | | e2term |
989 // +-------+ +---------+ +---------+
995 // |------------->| |
998 // | |------------->|
1000 // | SubDelReq 2 | |
1003 // |------------->| |
1005 // | | SubDelResp 1 |
1006 // | |<-------------|
1008 // | SubDelResp 1 | |
1009 // |<-------------| |
1011 // | SubDelResp 2 | |
1012 // |<-------------| |
1014 //-----------------------------------------------------------------------------
1016 func TestSubDelReqCollision(t *testing.T) {
1017 CaseBegin("TestSubDelReqCollision")
1020 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1021 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1022 e2termConn1.SendSubsResp(t, crereq, cremsg)
1023 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1026 xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1027 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1029 // Subs Delete colliding
1030 seqBef := mainCtrl.get_msgcounter(t)
1031 deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1032 xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq
1033 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
1035 // hack as there is no real way to see has message be handled.
1036 // Previuos counter check just tells that is has been received by submgr
1037 // --> artificial delay
1038 <-time.After(1 * time.Second)
1040 // Del resp for first and second
1041 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1043 // don't care in which order responses are received
1044 xappConn1.RecvSubsDelResp(t, nil)
1045 xappConn1.RecvSubsDelResp(t, nil)
1047 //Wait that subs is cleaned
1048 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1050 xappConn1.TestMsgChanEmpty(t)
1051 xappConn2.TestMsgChanEmpty(t)
1052 e2termConn1.TestMsgChanEmpty(t)
1053 mainCtrl.wait_registry_empty(t, 10)
1056 //-----------------------------------------------------------------------------
1057 // TestSubReqAndSubDelOkTwoParallel
1060 // +-------+ +-------+ +---------+ +---------+
1061 // | xapp | | xapp | | submgr | | e2term |
1062 // +-------+ +-------+ +---------+ +---------+
1067 // | |------------->| |
1070 // | | |------------->|
1073 // |------------------------>| |
1076 // | | |------------->|
1079 // | | |<-------------|
1081 // | |<-------------| |
1084 // | | |<-------------|
1086 // |<------------------------| |
1088 // | | [SUBS 1 DELETE] |
1090 // | | [SUBS 2 DELETE] |
1093 //-----------------------------------------------------------------------------
1095 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
1096 CaseBegin("TestSubReqAndSubDelOkTwoParallel")
1099 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1101 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1102 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1105 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1108 rparams2.Req.EventTriggerDefinition.Data.Length = 1
1109 rparams2.Req.EventTriggerDefinition.Data.Data = make([]uint8, rparams2.Req.EventTriggerDefinition.Data.Length)
1110 rparams2.Req.EventTriggerDefinition.Data.Data[0] = 2
1112 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1113 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1116 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1117 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1120 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1121 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1124 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1125 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1126 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1127 xappConn1.RecvSubsDelResp(t, deltrans1)
1128 //Wait that subs is cleaned
1129 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1132 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1133 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1134 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1135 xappConn2.RecvSubsDelResp(t, deltrans2)
1136 //Wait that subs is cleaned
1137 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1139 xappConn1.TestMsgChanEmpty(t)
1140 xappConn2.TestMsgChanEmpty(t)
1141 e2termConn1.TestMsgChanEmpty(t)
1142 mainCtrl.wait_registry_empty(t, 10)
1145 //-----------------------------------------------------------------------------
1146 // TestSameSubsDiffRan
1147 // Same subscription to different RANs
1150 // +-------+ +---------+ +---------+
1151 // | xapp | | submgr | | e2term |
1152 // +-------+ +---------+ +---------+
1157 // |------------->| |
1160 // | |------------->|
1162 // | | SubResp(r1) |
1163 // | |<-------------|
1165 // | SubResp(r1) | |
1166 // |<-------------| |
1169 // |------------->| |
1172 // | |------------->|
1174 // | | SubResp(r2) |
1175 // | |<-------------|
1177 // | SubResp(r2) | |
1178 // |<-------------| |
1180 // | [SUBS r1 DELETE] |
1182 // | [SUBS r2 DELETE] |
1185 //-----------------------------------------------------------------------------
1186 func TestSameSubsDiffRan(t *testing.T) {
1187 CaseBegin("TestSameSubsDiffRan")
1190 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1191 xappConn1.SendSubsReq(t, nil, cretrans1)
1192 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1193 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1194 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1197 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
1198 xappConn1.SendSubsReq(t, nil, cretrans2)
1199 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1200 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1201 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1204 deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1205 xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
1206 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1207 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1208 xappConn1.RecvSubsDelResp(t, deltrans1)
1209 //Wait that subs is cleaned
1210 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1213 deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
1214 xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
1215 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1216 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1217 xappConn1.RecvSubsDelResp(t, deltrans2)
1218 //Wait that subs is cleaned
1219 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1221 xappConn1.TestMsgChanEmpty(t)
1222 xappConn2.TestMsgChanEmpty(t)
1223 e2termConn1.TestMsgChanEmpty(t)
1224 mainCtrl.wait_registry_empty(t, 10)
1227 //-----------------------------------------------------------------------------
1228 // TestSubReqRetryInSubmgr
1231 // +-------+ +---------+ +---------+
1232 // | xapp | | submgr | | e2term |
1233 // +-------+ +---------+ +---------+
1236 // |------------->| |
1239 // | |------------->|
1243 // | |------------->|
1246 // | |<-------------|
1249 // |<-------------| |
1251 // | [SUBS DELETE] |
1254 //-----------------------------------------------------------------------------
1256 func TestSubReqRetryInSubmgr(t *testing.T) {
1257 CaseBegin("TestSubReqRetryInSubmgr start")
1259 // Init counter check
1260 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1261 Counter{cSubReqFromXapp, 1},
1262 Counter{cSubReqToE2, 1},
1263 Counter{cSubReReqToE2, 1},
1264 Counter{cSubRespFromE2, 1},
1265 Counter{cSubRespToXapp, 1},
1266 Counter{cSubDelReqFromXapp, 1},
1267 Counter{cSubDelReqToE2, 1},
1268 Counter{cSubDelRespFromE2, 1},
1269 Counter{cSubDelRespToXapp, 1},
1272 // Xapp: Send SubsReq
1273 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1275 // E2t: Receive 1st SubsReq
1276 e2termConn1.RecvSubsReq(t)
1278 // E2t: Receive 2nd SubsReq and send SubsResp
1279 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1280 e2termConn1.SendSubsResp(t, crereq, cremsg)
1282 // Xapp: Receive SubsResp
1283 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1285 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1286 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1287 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1288 xappConn1.RecvSubsDelResp(t, deltrans)
1290 // Wait that subs is cleaned
1291 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1293 xappConn1.TestMsgChanEmpty(t)
1294 xappConn2.TestMsgChanEmpty(t)
1295 e2termConn1.TestMsgChanEmpty(t)
1296 mainCtrl.wait_registry_empty(t, 10)
1298 mainCtrl.VerifyCounterValues(t)
1301 //-----------------------------------------------------------------------------
1302 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
1305 // +-------+ +---------+ +---------+
1306 // | xapp | | submgr | | e2term |
1307 // +-------+ +---------+ +---------+
1310 // |------------->| |
1313 // | |------------->|
1317 // | |------------->|
1320 // | |------------->|
1323 // | |<-------------|
1326 //-----------------------------------------------------------------------------
1327 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
1328 CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
1330 // Init counter check
1331 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1332 Counter{cSubReqFromXapp, 1},
1333 Counter{cSubReqToE2, 1},
1334 Counter{cSubReReqToE2, 1},
1335 Counter{cSubReqTimerExpiry, 2},
1336 Counter{cSubDelReqToE2, 1},
1337 Counter{cSubDelRespFromE2, 1},
1340 // Xapp: Send SubsReq
1341 xappConn1.SendSubsReq(t, nil, nil)
1343 // E2t: Receive 1st SubsReq
1344 e2termConn1.RecvSubsReq(t)
1346 // E2t: Receive 2nd SubsReq
1347 e2termConn1.RecvSubsReq(t)
1349 // E2t: Send receive SubsDelReq and send SubsResp
1350 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1351 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1353 // Wait that subs is cleaned
1354 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 10)
1356 xappConn1.TestMsgChanEmpty(t)
1357 xappConn2.TestMsgChanEmpty(t)
1358 e2termConn1.TestMsgChanEmpty(t)
1359 mainCtrl.wait_registry_empty(t, 10)
1361 mainCtrl.VerifyCounterValues(t)
1364 //-----------------------------------------------------------------------------
1365 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
1368 // +-------+ +---------+ +---------+
1369 // | xapp | | submgr | | e2term |
1370 // +-------+ +---------+ +---------+
1373 // |------------->| |
1376 // | |------------->|
1380 // | |------------->|
1383 // | |------------->|
1387 // | |------------->|
1391 //-----------------------------------------------------------------------------
1393 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
1394 CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
1396 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1397 Counter{cSubReqFromXapp, 1},
1398 Counter{cSubReqToE2, 1},
1399 Counter{cSubReReqToE2, 1},
1400 Counter{cSubReqTimerExpiry, 2},
1401 Counter{cSubDelReqToE2, 1},
1402 Counter{cSubDelReReqToE2, 1},
1403 Counter{cSubDelReqTimerExpiry, 2},
1406 // Xapp: Send SubsReq
1407 xappConn1.SendSubsReq(t, nil, nil)
1409 // E2t: Receive 1st SubsReq
1410 e2termConn1.RecvSubsReq(t)
1412 // E2t: Receive 2nd SubsReq
1413 e2termConn1.RecvSubsReq(t)
1415 // E2t: Receive 1st SubsDelReq
1416 e2termConn1.RecvSubsDelReq(t)
1418 // E2t: Receive 2nd SubsDelReq
1419 delreq, _ := e2termConn1.RecvSubsDelReq(t)
1421 // Wait that subs is cleaned
1422 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 15)
1424 xappConn1.TestMsgChanEmpty(t)
1425 xappConn2.TestMsgChanEmpty(t)
1426 e2termConn1.TestMsgChanEmpty(t)
1427 mainCtrl.wait_registry_empty(t, 10)
1429 mainCtrl.VerifyCounterValues(t)
1432 //-----------------------------------------------------------------------------
1433 // TestSubReqSubFailRespInSubmgr
1436 // +-------+ +---------+ +---------+
1437 // | xapp | | submgr | | e2term |
1438 // +-------+ +---------+ +---------+
1441 // |------------->| |
1444 // | |------------->|
1447 // | |<-------------|
1450 // |<-------------| |
1453 //-----------------------------------------------------------------------------
1455 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1456 CaseBegin("TestSubReqSubFailRespInSubmgr start")
1458 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1459 Counter{cSubReqFromXapp, 1},
1460 Counter{cSubReqToE2, 1},
1461 Counter{cSubFailFromE2, 1},
1462 Counter{cSubFailToXapp, 1},
1465 // Xapp: Send SubsReq
1466 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1468 // E2t: Receive SubsReq and send SubsFail (first)
1469 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1470 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1471 fparams1.Set(crereq1)
1472 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1474 // Xapp: Receive SubsFail
1475 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
1477 // Wait that subs is cleaned
1478 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1480 xappConn1.TestMsgChanEmpty(t)
1481 xappConn2.TestMsgChanEmpty(t)
1482 e2termConn1.TestMsgChanEmpty(t)
1483 mainCtrl.wait_registry_empty(t, 10)
1485 mainCtrl.VerifyCounterValues(t)
1488 //-----------------------------------------------------------------------------
1489 // TestSubDelReqRetryInSubmgr
1492 // +-------+ +---------+ +---------+
1493 // | xapp | | submgr | | e2term |
1494 // +-------+ +---------+ +---------+
1496 // | [SUBS CREATE] |
1500 // |------------->| |
1503 // | |------------->|
1506 // | |------------->|
1509 // | |<-------------|
1512 // |<-------------| |
1514 //-----------------------------------------------------------------------------
1516 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1518 CaseBegin("TestSubDelReqRetryInSubmgr start")
1521 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1522 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1523 e2termConn1.SendSubsResp(t, crereq, cremsg)
1524 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1527 // Xapp: Send SubsDelReq
1528 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1530 // E2t: Receive 1st SubsDelReq
1531 e2termConn1.RecvSubsDelReq(t)
1533 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1534 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1535 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1537 // Xapp: Receive SubsDelResp
1538 xappConn1.RecvSubsDelResp(t, deltrans)
1540 // Wait that subs is cleaned
1541 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1543 xappConn1.TestMsgChanEmpty(t)
1544 xappConn2.TestMsgChanEmpty(t)
1545 e2termConn1.TestMsgChanEmpty(t)
1546 mainCtrl.wait_registry_empty(t, 10)
1549 //-----------------------------------------------------------------------------
1550 // TestSubDelReqTwoRetriesNoRespInSubmgr
1553 // +-------+ +---------+ +---------+
1554 // | xapp | | submgr | | e2term |
1555 // +-------+ +---------+ +---------+
1557 // | [SUBS CREATE] |
1561 // |------------->| |
1564 // | |------------->|
1567 // | |------------->|
1571 // |<-------------| |
1573 //-----------------------------------------------------------------------------
1575 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1577 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
1580 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1581 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1582 e2termConn1.SendSubsResp(t, crereq, cremsg)
1583 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1586 // Xapp: Send SubsDelReq
1587 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1589 // E2t: Receive 1st SubsDelReq
1590 e2termConn1.RecvSubsDelReq(t)
1592 // E2t: Receive 2nd SubsDelReq
1593 e2termConn1.RecvSubsDelReq(t)
1595 // Xapp: Receive SubsDelResp
1596 xappConn1.RecvSubsDelResp(t, deltrans)
1598 // Wait that subs is cleaned
1599 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1601 xappConn1.TestMsgChanEmpty(t)
1602 xappConn2.TestMsgChanEmpty(t)
1603 e2termConn1.TestMsgChanEmpty(t)
1604 mainCtrl.wait_registry_empty(t, 10)
1607 //-----------------------------------------------------------------------------
1608 // TestSubDelReqSubDelFailRespInSubmgr
1611 // +-------+ +---------+ +---------+
1612 // | xapp | | submgr | | e2term |
1613 // +-------+ +---------+ +---------+
1615 // | [SUBS CREATE] |
1619 // |------------->| |
1622 // | |------------->|
1625 // | |<-------------|
1628 // |<-------------| |
1631 //-----------------------------------------------------------------------------
1633 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1634 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1636 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1637 Counter{cSubReqFromXapp, 1},
1638 Counter{cSubReqToE2, 1},
1639 Counter{cSubRespFromE2, 1},
1640 Counter{cSubRespToXapp, 1},
1641 Counter{cSubDelReqFromXapp, 1},
1642 Counter{cSubDelReqToE2, 1},
1643 Counter{cSubDelFailFromE2, 1},
1644 Counter{cSubDelRespToXapp, 1},
1648 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1649 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1650 e2termConn1.SendSubsResp(t, crereq, cremsg)
1651 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1653 // Xapp: Send SubsDelReq
1654 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1656 // E2t: Send receive SubsDelReq and send SubsDelFail
1657 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1658 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1660 // Xapp: Receive SubsDelResp
1661 xappConn1.RecvSubsDelResp(t, deltrans)
1663 // Wait that subs is cleaned
1664 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1666 xappConn1.TestMsgChanEmpty(t)
1667 xappConn2.TestMsgChanEmpty(t)
1668 e2termConn1.TestMsgChanEmpty(t)
1669 mainCtrl.wait_registry_empty(t, 10)
1671 mainCtrl.VerifyCounterValues(t)
1674 //-----------------------------------------------------------------------------
1675 // TestSubReqAndSubDelOkSameAction
1678 // +-------+ +-------+ +---------+ +---------+
1679 // | xapp2 | | xapp1 | | submgr | | e2term |
1680 // +-------+ +-------+ +---------+ +---------+
1685 // | |------------->| |
1688 // | | |------------->|
1690 // | | |<-------------|
1692 // | |<-------------| |
1695 // |--------------------------->| |
1698 // |<---------------------------| |
1700 // | | SubDelReq 1 | |
1701 // | |------------->| |
1703 // | | SubDelResp 1 | |
1704 // | |<-------------| |
1706 // | SubDelReq 2 | |
1707 // |--------------------------->| |
1709 // | | | SubDelReq 2 |
1710 // | | |------------->|
1712 // | | | SubDelReq 2 |
1713 // | | |------------->|
1715 // | SubDelResp 2 | |
1716 // |<---------------------------| |
1718 //-----------------------------------------------------------------------------
1719 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
1720 CaseBegin("TestSubReqAndSubDelOkSameAction")
1722 // Init counter check
1723 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1724 Counter{cSubReqFromXapp, 2},
1725 Counter{cSubReqToE2, 1},
1726 Counter{cSubRespFromE2, 1},
1727 Counter{cSubRespToXapp, 2},
1728 Counter{cMergedSubscriptions, 1},
1729 Counter{cUnmergedSubscriptions, 1},
1730 Counter{cSubDelReqFromXapp, 2},
1731 Counter{cSubDelReqToE2, 1},
1732 Counter{cSubDelRespFromE2, 1},
1733 Counter{cSubDelRespToXapp, 2},
1737 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1739 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1740 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1741 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1742 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1745 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1747 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1748 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1750 resp, _ := xapp.Subscription.QuerySubscriptions()
1751 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1752 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1753 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
1756 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1757 xappConn1.RecvSubsDelResp(t, deltrans1)
1760 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1761 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1762 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1763 xappConn2.RecvSubsDelResp(t, deltrans2)
1764 //Wait that subs is cleaned
1765 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1767 xappConn1.TestMsgChanEmpty(t)
1768 xappConn2.TestMsgChanEmpty(t)
1769 e2termConn1.TestMsgChanEmpty(t)
1770 mainCtrl.wait_registry_empty(t, 10)
1772 mainCtrl.VerifyCounterValues(t)
1775 //-----------------------------------------------------------------------------
1776 // TestSubReqAndSubDelOkSameActionParallel
1779 // +-------+ +-------+ +---------+ +---------+
1780 // | xapp2 | | xapp1 | | submgr | | e2term |
1781 // +-------+ +-------+ +---------+ +---------+
1786 // | |------------->| |
1789 // | | |------------->|
1791 // |--------------------------->| |
1793 // | | |<-------------|
1795 // | |<-------------| |
1798 // |<---------------------------| |
1800 // | | SubDelReq 1 | |
1801 // | |------------->| |
1803 // | | SubDelResp 1 | |
1804 // | |<-------------| |
1806 // | SubDelReq 2 | |
1807 // |--------------------------->| |
1809 // | | | SubDelReq 2 |
1810 // | | |------------->|
1812 // | | | SubDelReq 2 |
1813 // | | |------------->|
1815 // | SubDelResp 2 | |
1816 // |<---------------------------| |
1818 //-----------------------------------------------------------------------------
1819 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1820 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1823 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1825 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1826 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1829 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1831 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1834 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1835 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1838 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1841 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1842 xappConn1.RecvSubsDelResp(t, deltrans1)
1845 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1846 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1847 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1848 xappConn2.RecvSubsDelResp(t, deltrans2)
1850 //Wait that subs is cleaned
1851 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1853 xappConn1.TestMsgChanEmpty(t)
1854 xappConn2.TestMsgChanEmpty(t)
1855 e2termConn1.TestMsgChanEmpty(t)
1856 mainCtrl.wait_registry_empty(t, 10)
1859 //-----------------------------------------------------------------------------
1860 // TestSubReqAndSubDelNokSameActionParallel
1863 // +-------+ +-------+ +---------+ +---------+
1864 // | xapp2 | | xapp1 | | submgr | | e2term |
1865 // +-------+ +-------+ +---------+ +---------+
1870 // | |------------->| |
1873 // | | |------------->|
1875 // |--------------------------->| |
1877 // | | |<-------------|
1880 // | |<-------------| |
1883 // |<---------------------------| |
1885 //-----------------------------------------------------------------------------
1886 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1887 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1890 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1892 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1894 // E2t: Receive SubsReq (first)
1895 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1898 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1900 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1901 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1902 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1904 // E2t: send SubsFail (first)
1905 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1906 fparams1.Set(crereq1)
1907 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1910 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1912 xappConn2.RecvSubsFail(t, cretrans2)
1914 //Wait that subs is cleaned
1915 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1917 xappConn1.TestMsgChanEmpty(t)
1918 xappConn2.TestMsgChanEmpty(t)
1919 e2termConn1.TestMsgChanEmpty(t)
1920 mainCtrl.wait_registry_empty(t, 10)
1923 //-----------------------------------------------------------------------------
1924 // TestSubReqAndSubDelNoAnswerSameActionParallel
1927 // +-------+ +-------+ +---------+ +---------+
1928 // | xapp2 | | xapp1 | | submgr | | e2term |
1929 // +-------+ +-------+ +---------+ +---------+
1934 // | |------------->| |
1937 // | | |------------->|
1939 // |--------------------------->| |
1942 // | | |------------->|
1945 // | | | SubDelReq |
1946 // | | |------------->|
1948 // | | | SubDelResp |
1949 // | | |<-------------|
1951 //-----------------------------------------------------------------------------
1952 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1953 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1956 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1958 xappConn1.SendSubsReq(t, rparams1, nil)
1960 crereq1, _ := e2termConn1.RecvSubsReq(t)
1963 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1965 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1966 xappConn2.SendSubsReq(t, rparams2, nil)
1967 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1969 //Req1 (retransmitted)
1970 e2termConn1.RecvSubsReq(t)
1972 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1973 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1975 //Wait that subs is cleaned
1976 mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10)
1978 xappConn1.TestMsgChanEmpty(t)
1979 xappConn2.TestMsgChanEmpty(t)
1980 e2termConn1.TestMsgChanEmpty(t)
1981 mainCtrl.wait_registry_empty(t, 15)
1984 //----------------------------- Policy cases ---------------------------------
1985 //-----------------------------------------------------------------------------
1986 // TestSubReqPolicyAndSubDelOk
1989 // +-------+ +---------+ +---------+
1990 // | xapp | | submgr | | e2term |
1991 // +-------+ +---------+ +---------+
1994 // |------------->| |
1997 // | |------------->|
2000 // | |<-------------|
2003 // |<-------------| |
2007 // |------------->| |
2010 // | |------------->|
2013 // | |<-------------|
2016 // |<-------------| |
2018 //-----------------------------------------------------------------------------
2019 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
2020 CaseBegin("TestSubReqAndSubDelOk")
2022 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2024 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
2025 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2027 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2028 e2termConn1.SendSubsResp(t, crereq, cremsg)
2029 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2030 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2031 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2033 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2034 xappConn1.RecvSubsDelResp(t, deltrans)
2036 //Wait that subs is cleaned
2037 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2039 xappConn1.TestMsgChanEmpty(t)
2040 xappConn2.TestMsgChanEmpty(t)
2041 e2termConn1.TestMsgChanEmpty(t)
2042 mainCtrl.wait_registry_empty(t, 10)
2045 //-----------------------------------------------------------------------------
2046 // TestSubReqPolicyChangeAndSubDelOk
2049 // +-------+ +---------+ +---------+
2050 // | xapp | | submgr | | e2term |
2051 // +-------+ +---------+ +---------+
2054 // |------------->| |
2057 // | |------------->|
2060 // | |<-------------|
2063 // |<-------------| |
2066 // |------------->| |
2069 // | |------------->|
2072 // | |<-------------|
2075 // |<-------------| |
2078 // |------------->| |
2081 // | |------------->|
2084 // | |<-------------|
2087 // |<-------------| |
2089 //-----------------------------------------------------------------------------
2091 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
2092 CaseBegin("TestSubReqAndSubDelOk")
2094 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2096 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
2097 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2099 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2100 e2termConn1.SendSubsResp(t, crereq, cremsg)
2101 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2104 rparams1.Req.RequestId.InstanceId = e2SubsId
2105 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
2106 xappConn1.SendSubsReq(t, rparams1, cretrans)
2108 crereq, cremsg = e2termConn1.RecvSubsReq(t)
2109 e2termConn1.SendSubsResp(t, crereq, cremsg)
2110 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2111 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2112 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2114 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2115 xappConn1.RecvSubsDelResp(t, deltrans)
2117 //Wait that subs is cleaned
2118 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2120 xappConn1.TestMsgChanEmpty(t)
2121 xappConn2.TestMsgChanEmpty(t)
2122 e2termConn1.TestMsgChanEmpty(t)
2123 mainCtrl.wait_registry_empty(t, 10)
2126 //-----------------------------------------------------------------------------
2127 // TestSubReqAndSubDelOkTwoE2termParallel
2130 // +-------+ +---------+ +---------+ +---------+
2131 // | xapp | | submgr | | e2term1 | | e2term2 |
2132 // +-------+ +---------+ +---------+ +---------+
2137 // |------------->| | |
2140 // | |------------->| |
2143 // |------------->| | |
2146 // | |---------------------------->|
2149 // | |<-------------| |
2151 // |<-------------| | |
2153 // | |<----------------------------|
2155 // |<-------------| | |
2157 // | [SUBS 1 DELETE] | |
2159 // | [SUBS 2 DELETE] | |
2162 //-----------------------------------------------------------------------------
2163 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
2164 CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
2167 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
2168 xappConn1.SendSubsReq(t, nil, cretrans1)
2169 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2171 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
2172 xappConn1.SendSubsReq(t, nil, cretrans2)
2173 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
2176 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2177 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2180 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
2181 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
2184 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2185 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2186 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2187 xappConn1.RecvSubsDelResp(t, deltrans1)
2188 //Wait that subs is cleaned
2189 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
2192 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
2193 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
2194 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
2195 xappConn1.RecvSubsDelResp(t, deltrans2)
2196 //Wait that subs is cleaned
2197 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2199 xappConn1.TestMsgChanEmpty(t)
2200 xappConn2.TestMsgChanEmpty(t)
2201 e2termConn1.TestMsgChanEmpty(t)
2202 e2termConn2.TestMsgChanEmpty(t)
2203 mainCtrl.wait_registry_empty(t, 10)
2206 //-----------------------------------------------------------------------------
2207 // TestSubReqInsertAndSubDelOk
2210 // +-------+ +---------+ +---------+
2211 // | xapp | | submgr | | e2term |
2212 // +-------+ +---------+ +---------+
2215 // |------------->| |
2218 // | |------------->|
2221 // | |<-------------|
2224 // |<-------------| |
2228 // |------------->| |
2231 // | |------------->|
2234 // | |<-------------|
2237 // |<-------------| |
2239 //-----------------------------------------------------------------------------
2240 func TestSubReqInsertAndSubDelOk(t *testing.T) {
2241 CaseBegin("TestInsertSubReqAndSubDelOk")
2243 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2245 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeInsert
2246 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2248 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2249 e2termConn1.SendSubsResp(t, crereq, cremsg)
2250 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2251 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2252 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2254 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2255 xappConn1.RecvSubsDelResp(t, deltrans)
2257 //Wait that subs is cleaned
2258 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2260 xappConn1.TestMsgChanEmpty(t)
2261 xappConn2.TestMsgChanEmpty(t)
2262 e2termConn1.TestMsgChanEmpty(t)
2263 mainCtrl.wait_registry_empty(t, 10)
2266 //-----------------------------------------------------------------------------
2267 // TestSubReqRetransmissionWithSameSubIdDiffXid
2269 // This case simulates case where xApp restarts and starts sending same
2270 // subscription requests which have already subscribed successfully
2273 // +-------+ +---------+ +---------+
2274 // | xapp | | submgr | | e2term |
2275 // +-------+ +---------+ +---------+
2278 // |------------->| |
2281 // | |------------->|
2284 // | |<-------------|
2287 // |<-------------| |
2289 // | xApp restart | |
2292 // | (retrans with same xApp generated subid but diff xid)
2293 // |------------->| |
2296 // |<-------------| |
2298 // | [SUBS DELETE] |
2301 //-----------------------------------------------------------------------------
2302 func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) {
2303 CaseBegin("TestSubReqRetransmissionWithSameSubIdDiffXid")
2306 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2307 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2308 e2termConn1.SendSubsResp(t, crereq, cremsg)
2309 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2311 // xApp restart here
2312 // --> artificial delay
2313 <-time.After(1 * time.Second)
2316 cretrans = xappConn1.SendSubsReq(t, nil, nil) //Retransmitted SubReq
2317 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2320 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2321 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2322 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2323 xappConn1.RecvSubsDelResp(t, deltrans)
2325 //Wait that subs is cleaned
2326 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2328 xappConn1.TestMsgChanEmpty(t)
2329 xappConn2.TestMsgChanEmpty(t)
2330 e2termConn1.TestMsgChanEmpty(t)
2331 mainCtrl.wait_registry_empty(t, 10)
2334 //-----------------------------------------------------------------------------
2335 // TestSubReqNokAndSubDelOkWithRestartInMiddle
2338 // +-------+ +---------+ +---------+
2339 // | xapp | | submgr | | e2term |
2340 // +-------+ +---------+ +---------+
2343 // |------------->| |
2346 // | |------------->|
2351 // | Submgr restart |
2355 // | |------------->|
2358 // | |<-------------|
2361 //-----------------------------------------------------------------------------
2363 func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
2364 CaseBegin("TestSubReqNokAndSubDelOkWithRestartInMiddle")
2366 // Remove possible existing subscrition
2367 mainCtrl.removeExistingSubscriptions(t)
2369 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
2370 xappConn1.SendSubsReq(t, nil, nil)
2371 e2termConn1.RecvSubsReq(t)
2372 mainCtrl.SetResetTestFlag(t, false)
2374 resp, _ := xapp.Subscription.QuerySubscriptions()
2375 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2376 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2377 e2SubsId := uint32(resp[0].SubscriptionID)
2378 t.Logf("e2SubsId = %v", e2SubsId)
2380 mainCtrl.SimulateRestart(t)
2381 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2383 // Submgr send delete for uncompleted subscription
2384 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2385 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2387 // Wait that subs is cleaned
2388 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2390 xappConn1.TestMsgChanEmpty(t)
2391 xappConn2.TestMsgChanEmpty(t)
2392 e2termConn1.TestMsgChanEmpty(t)
2393 mainCtrl.wait_registry_empty(t, 10)
2396 //-----------------------------------------------------------------------------
2397 // TestSubReqAndSubDelOkWithRestartInMiddle
2400 // +-------+ +---------+ +---------+
2401 // | xapp | | submgr | | e2term |
2402 // +-------+ +---------+ +---------+
2405 // |------------->| |
2408 // | |------------->|
2411 // | |<-------------|
2414 // |<-------------| |
2417 // | Submgr restart |
2420 // |------------->| |
2423 // | |------------->|
2426 // | |<-------------|
2429 // |<-------------| |
2431 //-----------------------------------------------------------------------------
2433 func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
2434 CaseBegin("TestSubReqAndSubDelOkWithRestartInMiddle")
2436 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2437 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2438 e2termConn1.SendSubsResp(t, crereq, cremsg)
2439 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2441 // Check subscription
2442 resp, _ := xapp.Subscription.QuerySubscriptions()
2443 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2444 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2445 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2447 mainCtrl.SimulateRestart(t)
2448 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2450 // Check that subscription is restored correctly after restart
2451 resp, _ = xapp.Subscription.QuerySubscriptions()
2452 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2453 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2454 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2456 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2457 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2458 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2459 xappConn1.RecvSubsDelResp(t, deltrans)
2461 //Wait that subs is cleaned
2462 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2464 xappConn1.TestMsgChanEmpty(t)
2465 xappConn2.TestMsgChanEmpty(t)
2466 e2termConn1.TestMsgChanEmpty(t)
2467 mainCtrl.wait_registry_empty(t, 10)
2470 //-----------------------------------------------------------------------------
2471 // TestSubReqAndSubDelOkSameActionWithRestartsInMiddle
2474 // +-------+ +-------+ +---------+ +---------+
2475 // | xapp2 | | xapp1 | | submgr | | e2term |
2476 // +-------+ +-------+ +---------+ +---------+
2481 // | |------------->| |
2484 // | | |------------->|
2486 // | | |<-------------|
2488 // | |<-------------| |
2491 // | submgr restart |
2496 // |--------------------------->| |
2499 // |<---------------------------| |
2501 // | | SubDelReq 1 | |
2502 // | |------------->| |
2504 // | | SubDelResp 1 | |
2505 // | |<-------------| |
2509 // | submgr restart |
2512 // | SubDelReq 2 | |
2513 // |--------------------------->| |
2515 // | | | SubDelReq 2 |
2516 // | | |------------->|
2518 // | | | SubDelReq 2 |
2519 // | | |------------->|
2521 // | SubDelResp 2 | |
2522 // |<---------------------------| |
2524 //-----------------------------------------------------------------------------
2526 func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
2527 CaseBegin("TestSubReqAndSubDelOkSameActionWithRestartsInMiddle")
2530 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2532 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2533 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2534 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2535 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2538 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2540 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2541 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
2543 // Check subscription
2544 resp, _ := xapp.Subscription.QuerySubscriptions() ////////////////////////////////
2545 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2546 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2547 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2549 mainCtrl.SimulateRestart(t)
2550 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2552 // Check that subscription is restored correctly after restart
2553 resp, _ = xapp.Subscription.QuerySubscriptions()
2554 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2555 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2556 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2559 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2560 xapp.Logger.Debug("xappConn1.RecvSubsDelResp")
2561 xappConn1.RecvSubsDelResp(t, deltrans1)
2562 xapp.Logger.Debug("xappConn1.RecvSubsDelResp received")
2564 mainCtrl.SimulateRestart(t)
2565 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2568 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
2569 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2571 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2572 xappConn2.RecvSubsDelResp(t, deltrans2)
2574 //Wait that subs is cleaned
2575 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2577 xappConn1.TestMsgChanEmpty(t)
2578 xappConn2.TestMsgChanEmpty(t)
2579 e2termConn1.TestMsgChanEmpty(t)
2580 mainCtrl.wait_registry_empty(t, 10)
2583 //*****************************************************************************
2584 // REST interface test cases
2585 //*****************************************************************************
2587 //-----------------------------------------------------------------------------
2588 // Test debug GET and POST requests
2591 // +-------+ +---------+
2592 // | user | | submgr |
2593 // +-------+ +---------+
2600 func TestGetSubscriptions(t *testing.T) {
2602 mainCtrl.sendGetRequest(t, "localhost:8088", "/ric/v1/subscriptions")
2605 func TestGetSymptomData(t *testing.T) {
2607 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/symptomdata")
2610 func TestPostdeleteSubId(t *testing.T) {
2612 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/deletesubid=1")
2615 func TestPostEmptyDb(t *testing.T) {
2617 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/emptydb")
2620 func TestGetRestSubscriptions(t *testing.T) {
2622 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/restsubscriptions")
2625 //-----------------------------------------------------------------------------
2626 // TestRESTSubReqAndRouteNok
2629 // +-------+ +---------+ +---------+
2630 // | xapp | | submgr | | rtmgr |
2631 // +-------+ +---------+ +---------+
2634 // |---------------->| |
2636 // | RESTSubResp | |
2637 // |<----------------| |
2638 // | | RouteCreate |
2639 // | |------------->|
2641 // | | RouteCreate |
2643 // | |(Bad request) |
2644 // | |<-------------|
2646 // |<----------------| |
2648 // | [SUBS INT DELETE] |
2650 // | RESTSubDelReq | |
2651 // |---------------->| |
2652 // | RESTSubDelResp | |
2653 // |<----------------| |
2655 //-----------------------------------------------------------------------------
2656 func TestRESTSubReqAndRouteNok(t *testing.T) {
2657 CaseBegin("TestRESTSubReqAndRouteNok")
2659 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2660 Counter{cRestSubReqFromXapp, 1},
2661 Counter{cRestSubRespToXapp, 1},
2662 Counter{cRouteCreateFail, 1},
2663 Counter{cRestSubFailNotifToXapp, 1},
2664 Counter{cRestSubDelReqFromXapp, 1},
2665 Counter{cRestSubDelRespToXapp, 1},
2668 const subReqCount int = 1
2670 // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
2671 waiter := rtmgrHttp.AllocNextSleep(50, false)
2672 newSubsId := mainCtrl.get_registry_next_subid(t)
2675 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2676 restSubId := xappConn1.SendRESTSubsReq(t, params)
2677 xappConn1.ExpectRESTNotificationNok(t, restSubId, "failAll")
2678 waiter.WaitResult(t)
2680 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2681 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
2684 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2686 // Wait that subs is cleaned
2687 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2688 waitSubsCleanup(t, e2SubsId, 10)
2689 mainCtrl.VerifyCounterValues(t)
2692 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
2693 CaseBegin("TestSubReqAndRouteUpdateNok")
2695 //Init counter check
2696 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2697 Counter{cRestSubReqFromXapp, 2},
2698 Counter{cRestSubRespToXapp, 2},
2699 Counter{cSubReqToE2, 1},
2700 Counter{cSubRespFromE2, 1},
2701 Counter{cRestSubNotifToXapp, 1},
2702 Counter{cRestSubFailNotifToXapp, 1},
2703 Counter{cRouteCreateUpdateFail, 1},
2704 Counter{cRestSubDelReqFromXapp, 1},
2705 Counter{cSubDelReqToE2, 1},
2706 Counter{cSubDelRespFromE2, 1},
2707 Counter{cRestSubDelRespToXapp, 1},
2710 var params *teststube2ap.RESTSubsReqParams = nil
2713 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2715 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2717 // xapp2 ROUTE creation shall fail with 400 from rtmgr -> submgr
2718 waiter := rtmgrHttp.AllocNextEvent(false)
2719 newSubsId := mainCtrl.get_registry_next_subid(t)
2720 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
2721 params.SetMeid("RAN_NAME_1")
2722 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2723 xapp.Logger.Debug("Send REST subscriber request for second subscriber : %v", restSubId2)
2724 xappConn2.ExpectRESTNotificationNok(t, restSubId2, "allFail")
2725 waiter.WaitResult(t)
2726 // e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) - TOD: missing delete
2727 xappConn2.WaitRESTNotification(t, restSubId2)
2729 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2731 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2733 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2734 //Wait that subs is cleaned
2735 waitSubsCleanup(t, e2SubsId, 10)
2737 mainCtrl.VerifyCounterValues(t)
2740 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
2741 CaseBegin("TestRESTSubDelReqAndRouteDeleteNok")
2743 // Init counter check
2744 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2745 Counter{cRestSubReqFromXapp, 1},
2746 Counter{cRestSubRespToXapp, 1},
2747 Counter{cSubReqToE2, 1},
2748 Counter{cSubRespFromE2, 1},
2749 Counter{cRestSubNotifToXapp, 1},
2750 Counter{cRestSubDelReqFromXapp, 1},
2751 Counter{cRouteDeleteFail, 1},
2752 Counter{cSubDelReqToE2, 1},
2753 Counter{cSubDelRespFromE2, 1},
2754 Counter{cRestSubDelRespToXapp, 1},
2757 var params *teststube2ap.RESTSubsReqParams = nil
2760 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2762 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2764 waiter := rtmgrHttp.AllocNextEvent(false)
2765 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2766 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2767 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2768 waiter.WaitResult(t)
2770 waitSubsCleanup(t, e2SubsId, 10)
2772 mainCtrl.VerifyCounterValues(t)
2775 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
2776 CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok")
2778 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2779 Counter{cRestSubReqFromXapp, 2},
2780 Counter{cRestSubRespToXapp, 2},
2781 Counter{cSubReqToE2, 1},
2782 Counter{cSubRespFromE2, 1},
2783 Counter{cRestSubNotifToXapp, 2},
2784 Counter{cRestSubDelReqFromXapp, 2},
2785 Counter{cRouteDeleteUpdateFail, 1},
2786 Counter{cSubDelReqToE2, 1},
2787 Counter{cSubDelRespFromE2, 1},
2788 Counter{cRestSubDelRespToXapp, 2},
2791 var params *teststube2ap.RESTSubsReqParams = nil
2794 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2796 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2797 restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1")
2799 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
2801 //Del1, this shall fail on rtmgr side
2802 waiter := rtmgrHttp.AllocNextEvent(false)
2803 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2804 waiter.WaitResult(t)
2806 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"})
2809 deleteXapp2Subscription(t, &restSubId2)
2811 waitSubsCleanup(t, e2SubsId2, 10)
2812 mainCtrl.VerifyCounterValues(t)
2815 //-----------------------------------------------------------------------------
2816 // TestRESTSubReqRetransmission
2819 // +-------+ +---------+ +---------+
2820 // | xapp | | submgr | | e2term |
2821 // +-------+ +---------+ +---------+
2823 // | RESTSubReq1 | |
2824 // |---------------->| |
2826 // | RESTSubResp | |
2827 // |<----------------| |
2829 // | |------------->|
2831 // | RESTSubReq2 | |
2833 // |---------------->| |
2834 // | RESTSubResp(201)| |
2835 // |<----------------| |
2838 // | |<-------------|
2840 // |<----------------| |
2842 // | [SUBS DELETE] |
2845 //-----------------------------------------------------------------------------
2847 func TestRESTSubReqRetransmission(t *testing.T) {
2848 CaseBegin("TestRESTSubReqRetransmission")
2850 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2851 Counter{cRestSubReqFromXapp, 2},
2852 Counter{cRestSubRespToXapp, 2},
2853 Counter{cSubReqToE2, 1},
2854 Counter{cSubRespFromE2, 1},
2855 Counter{cRestSubNotifToXapp, 1},
2856 Counter{cRestSubDelReqFromXapp, 1},
2857 Counter{cSubDelReqToE2, 1},
2858 Counter{cSubDelRespFromE2, 1},
2859 Counter{cRestSubDelRespToXapp, 1},
2861 // Retry/duplicate will get the same way as the first request.
2862 // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
2863 // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
2866 const subReqCount int = 1
2868 // In order to force both XAPP's to create their own subscriptions, force rtmgr to block a while so that 2nd create
2869 // gets into execution before the rtmgrg responds for the first one.
2870 waiter := rtmgrHttp.AllocNextSleep(10, true)
2871 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2872 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
2873 xappConn2.SendRESTSubsReq(t, params)
2875 waiter.WaitResult(t)
2877 xappConn1.WaitListedRestNotifications(t, []string{restSubId1})
2879 // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
2880 // the order is not significant he6re.
2881 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2882 e2termConn1.SendSubsResp(t, crereq, cremsg)
2884 e2SubsIdA := <-xappConn1.ListedRESTNotifications
2885 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
2888 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
2889 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2890 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2892 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId}, 10)
2894 mainCtrl.VerifyCounterValues(t)
2897 //-----------------------------------------------------------------------------
2899 // +-------+ +---------+ +---------+ +---------+
2900 // | xapp | | submgr | | e2term | | rtmgr |
2901 // +-------+ +---------+ +---------+ +---------+
2903 // | RESTSubReq | | |
2904 // |---------------->| | |
2905 // | RESTSubResp | | |
2906 // |<----------------| | |
2907 // | | RouteCreate | |
2908 // | |--------------------------->|
2909 // | | RouteResponse| |
2910 // | |<---------------------------| // The order of these events may vary
2912 // | |------------->| | // The order of these events may vary
2914 // | |<-------------| |
2915 // | RESTNotif1 | | |
2916 // |<----------------| | |
2917 // | RESTSubReq | | |
2918 // | [RETRANS1] | | |
2919 // |---------------->| | |
2920 // | RESTNotif1 | | |
2921 // |<----------------| | |
2922 // | RESTSubReq | | |
2923 // | [RETRANS2] | | |
2924 // |---------------->| | |
2925 // | RESTNotif1 | | |
2926 // |<----------------| | |
2927 // | RESTSubDelReq | | |
2928 // |---------------->| | |
2929 // | | SubDelReq | |
2930 // | |------------->| |
2931 // | RESTSubDelResp| | |
2932 // |<----------------| | |
2933 // | | SubDelResp | |
2934 // | |<-------------| |
2937 //-----------------------------------------------------------------------------
2939 func TestRESTSubReqRetransmissionV2(t *testing.T) {
2940 CaseBegin("TestRESTSubReqRetransmissionV2")
2942 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2943 Counter{cRestSubReqFromXapp, 3},
2944 Counter{cRestSubRespToXapp, 3},
2945 Counter{cSubReqToE2, 1},
2946 Counter{cSubRespFromE2, 1},
2947 Counter{cRestSubNotifToXapp, 3},
2948 Counter{cRestSubDelReqFromXapp, 1},
2949 Counter{cSubDelReqToE2, 1},
2950 Counter{cSubDelRespFromE2, 1},
2951 Counter{cRestSubDelRespToXapp, 1},
2954 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2956 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2958 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2961 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
2963 assert.Equal(t, restSubId_resend, restSubId)
2965 <-time.After(100 * time.Millisecond)
2968 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
2970 assert.Equal(t, restSubId_resend2, restSubId)
2972 <-time.After(100 * time.Millisecond)
2974 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2976 waitSubsCleanup(t, e2SubsId, 10)
2978 //Wait that subs is cleaned
2979 mainCtrl.VerifyCounterValues(t)
2982 //-----------------------------------------------------------------------------
2984 // +-------+ +---------+ +---------+ +---------+
2985 // | xapp | | submgr | | e2term | | rtmgr |
2986 // +-------+ +---------+ +---------+ +---------+
2988 // | RESTSubReq | | |
2989 // |---------------->| | |
2990 // | RESTSubResp | | |
2991 // |<----------------| | |
2992 // | | RouteCreate | |
2993 // | |--------------------------->|
2994 // | | RouteResponse| |
2995 // | |<---------------------------| // The order of these events may vary
2997 // | |------------->| | // The order of these events may vary
2999 // | |<-------------| |
3000 // | RESTNotif1 | | |
3001 // |<----------------| | |
3002 // | RESTSubReq | | |
3003 // | [RETRANS, with RESTsubsId] | |
3004 // |---------------->| | |
3005 // | RESTNotif1 | | |
3006 // |<----------------| | |
3007 // | RESTSubReq | | |
3008 // | [RETRANS, without RESTsubsId] | |
3009 // |---------------->| | |
3010 // | RESTNotif1 | | |
3011 // |<----------------| | |
3012 // | RESTSubDelReq | | |
3013 // |---------------->| | |
3014 // | | SubDelReq | |
3015 // | |------------->| |
3016 // | RESTSubDelResp| | |
3017 // |<----------------| | |
3018 // | | SubDelResp | |
3019 // | |<-------------| |
3022 //-----------------------------------------------------------------------------
3023 func TestRESTSubReqRetransmissionV3(t *testing.T) {
3024 CaseBegin("TestRESTSubReqRetransmissionV3")
3026 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3027 Counter{cRestSubReqFromXapp, 3},
3028 Counter{cRestSubRespToXapp, 3},
3029 Counter{cSubReqToE2, 1},
3030 Counter{cSubRespFromE2, 1},
3031 Counter{cRestSubNotifToXapp, 3},
3032 Counter{cRestSubDelReqFromXapp, 1},
3033 Counter{cSubDelReqToE2, 1},
3034 Counter{cSubDelRespFromE2, 1},
3035 Counter{cRestSubDelRespToXapp, 1},
3038 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3040 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3042 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3044 <-time.After(100 * time.Millisecond)
3046 //1.st resend with subscription ID
3047 params.SetSubscriptionID(&restSubId)
3048 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
3050 assert.Equal(t, restSubId_resend, restSubId)
3052 <-time.After(100 * time.Millisecond)
3054 //2.nd resend without subscription ID (faking app restart)
3055 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3056 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3058 assert.Equal(t, restSubId_resend2, restSubId)
3060 <-time.After(100 * time.Millisecond)
3062 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3064 waitSubsCleanup(t, e2SubsId, 10)
3066 //Wait that subs is cleaned
3067 mainCtrl.VerifyCounterValues(t)
3070 //-----------------------------------------------------------------------------
3072 // +-------+ +---------+ +---------+ +---------+
3073 // | xapp | | submgr | | e2term | | rtmgr |
3074 // +-------+ +---------+ +---------+ +---------+
3076 // | RESTSubReq | | |
3077 // |---------------->| | |
3078 // | RESTSubResp | | |
3079 // |<----------------| | |
3080 // | | RouteCreate | |
3081 // | |--------------------------->|
3082 // | | RouteResponse| |
3083 // | |<---------------------------|
3085 // | |------------->| |
3087 // | |<-------------| |
3088 // | RESTNotif1 | | |
3089 // |<----------------| | |
3090 // | RESTSubReq | | |
3091 // | [with RestSUbsId + one additional e2 subDetail]
3092 // |---------------->| | |
3093 // | RESTNotif1 | | |
3094 // | [for initial e2 subDetail] | |
3095 // |<----------------| | |
3096 // | | RouteCreate | |
3097 // | |--------------------------->|
3098 // | | RouteResponse| |
3099 // | |<---------------------------|
3101 // | |------------->| |
3103 // | |<-------------| |
3104 // | RESTNotif1 | | |
3105 // |<----------------| | |
3106 // | RESTSubReq | | |
3107 // | [with RESTsubsId initial request] |
3108 // |---------------->| | |
3109 // | RESTNotif1 | | |
3110 // |<----------------| | |
3111 // | RESTSubDelReq | | |
3112 // |---------------->| | |
3113 // | RESTSubDelResp| | |
3114 // |<----------------| | |
3115 // | | SubDelReq | |
3116 // | |------------->| |
3117 // | | SubDelResp | |
3118 // | |<-------------| |
3119 // | | SubDelReq | |
3120 // | |------------->| |
3121 // | | SubDelResp | |
3122 // | |<-------------| |
3125 //-----------------------------------------------------------------------------
3127 func TestRESTSubReqRetransmissionV4(t *testing.T) {
3128 CaseBegin("TestRESTSubReqRetransmissionV4")
3130 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3131 Counter{cRestSubReqFromXapp, 3},
3132 Counter{cRestSubRespToXapp, 3},
3133 Counter{cSubReqToE2, 2},
3134 Counter{cSubRespFromE2, 2},
3135 Counter{cRestSubNotifToXapp, 4},
3136 Counter{cRestSubDelReqFromXapp, 1},
3137 Counter{cSubDelReqToE2, 2},
3138 Counter{cSubDelRespFromE2, 2},
3139 Counter{cRestSubDelRespToXapp, 1},
3142 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3144 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3146 <-time.After(100 * time.Millisecond)
3148 // Send modified requst, this time with e2 subscriptions.
3149 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3150 params2.SetSubscriptionID(&restSubId)
3152 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3153 xappConn1.ExpectAnyNotification(t)
3154 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3155 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3156 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3157 assert.Equal(t, e2SubsId, e2SubsId1)
3159 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3161 xappConn1.DecrementRequestCount()
3162 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3163 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3164 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3165 assert.NotEqual(t, e2SubsId2, 0)
3167 <-time.After(100 * time.Millisecond)
3169 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3170 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3171 params.SetSubscriptionID(&restSubId)
3172 xappConn1.ExpectAnyNotification(t)
3173 // Resend the original request again with only one e2 subscription (detail), this time with restsubsid
3174 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3175 assert.Equal(t, restSubId_resend, restSubId_resend2)
3177 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3178 assert.Equal(t, e2SubsId, e2SubsId1)
3180 // Delete both e2 subscriptions
3181 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3182 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3183 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3185 waitSubsCleanup(t, e2SubsId, 10)
3187 //Wait that subs is cleaned
3188 mainCtrl.VerifyCounterValues(t)
3191 //-----------------------------------------------------------------------------
3193 // +-------+ +---------+ +---------+ +---------+
3194 // | xapp | | submgr | | e2term | | rtmgr |
3195 // +-------+ +---------+ +---------+ +---------+
3197 // | RESTSubReq | | |
3198 // |---------------->| | |
3199 // | RESTSubResp | | |
3200 // |<----------------| | |
3201 // | | RouteCreate | |
3202 // | |--------------------------->|
3203 // | | RouteResponse| |
3204 // | |<---------------------------|
3206 // | |------------->| |
3208 // | |<-------------| |
3209 // | RESTNotif1 | | |
3210 // |<----------------| | |
3211 // | RESTSubReq | | |
3212 // | [with RestSUbsId + one additional e2 subDetail]
3213 // |---------------->| | |
3214 // | RESTNotif1 | | |
3215 // | [for initial e2 subDetail] | |
3216 // |<----------------| | |
3217 // | | RouteCreate | |
3218 // | |--------------------------->|
3219 // | | RouteResponse| |
3220 // | |<---------------------------|
3222 // | |------------->| |
3224 // | |<-------------| |
3225 // | RESTNotif1 | | |
3226 // |<----------------| | |
3227 // | RESTSubReq | | |
3228 // | [without RESTsubsId initial request] |
3229 // |---------------->| | |
3230 // | RESTNotif1 | | |
3231 // |<----------------| | |
3232 // | RESTSubDelReq | | |
3233 // |---------------->| | |
3234 // | RESTSubDelResp| | |
3235 // |<----------------| | |
3236 // | | SubDelReq | |
3237 // | |------------->| |
3238 // | | SubDelResp | |
3239 // | |<-------------| |
3240 // | | SubDelReq | |
3241 // | |------------->| |
3242 // | | SubDelResp | |
3243 // | |<-------------| |
3246 //-----------------------------------------------------------------------------
3248 func TestRESTSubReqRetransmissionV5(t *testing.T) {
3249 CaseBegin("TestRESTSubReqRetransmissionV5")
3251 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3252 Counter{cRestSubReqFromXapp, 3},
3253 Counter{cRestSubRespToXapp, 3},
3254 Counter{cSubReqToE2, 2},
3255 Counter{cSubRespFromE2, 2},
3256 Counter{cRestSubNotifToXapp, 4},
3257 Counter{cRestSubDelReqFromXapp, 1},
3258 Counter{cSubDelReqToE2, 2},
3259 Counter{cSubDelRespFromE2, 2},
3260 Counter{cRestSubDelRespToXapp, 1},
3263 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3265 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3267 <-time.After(100 * time.Millisecond)
3269 // Send modified requst, this time with e2 subscriptions.
3270 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3271 params2.SetSubscriptionID(&restSubId)
3273 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3274 xappConn1.ExpectAnyNotification(t)
3275 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3276 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3278 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3279 assert.Equal(t, e2SubsId, e2SubsId1)
3280 // The first E2 subscription returns immediately, manually decrement expected request count for the remaining request handling
3281 xappConn1.DecrementRequestCount()
3283 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3285 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3286 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3287 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3288 assert.NotEqual(t, e2SubsId2, 0)
3290 <-time.After(100 * time.Millisecond)
3292 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3293 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3294 xappConn1.ExpectAnyNotification(t)
3295 // Resend the original request again with only one e2 subscription (detail), WITHOUT restsubsid
3296 // md5sum shall find the original request
3297 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3298 assert.Equal(t, restSubId_resend, restSubId_resend2)
3300 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3301 assert.Equal(t, e2SubsId, e2SubsId1)
3303 // Delete both e2 subscriptions
3304 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3305 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3306 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3308 waitSubsCleanup(t, e2SubsId, 10)
3310 //Wait that subs is cleaned
3311 mainCtrl.VerifyCounterValues(t)
3314 //-----------------------------------------------------------------------------
3316 // +-------+ +---------+ +---------+ +---------+
3317 // | xapp | | submgr | | e2term | | rtmgr |
3318 // +-------+ +---------+ +---------+ +---------+
3320 // | RESTSubReq | | |
3321 // |---------------->| | |
3322 // | RESTSubResp | | |
3323 // |<----------------| | |
3324 // | | RouteCreate | |
3325 // | |--------------------------->|
3326 // | | RouteResponse| |
3327 // | |<---------------------------|
3329 // | |------------->| |
3331 // | |<-------------| |
3332 // | RESTNotif1 | | |
3333 // |<----------------| | |
3334 // | RESTSubReq | | |
3335 // | [with RestSUbsId + one additional e2 subDetail]
3336 // |---------------->| | |
3337 // | RESTNotif1 | | |
3338 // | [for initial e2 subDetail] | |
3339 // |<----------------| | |
3340 // | | RouteCreate | |
3341 // | |--------------------------->|
3342 // | | RouteResponse| |
3343 // | |<---------------------------|
3345 // | |------------->| |
3347 // | |<-------------| |
3348 // | RESTNotif1 | | |
3349 // |<----------------| | |
3350 // | RESTSubDelReq | | |
3351 // |---------------->| | |
3352 // | RESTSubDelResp| | |
3353 // |<----------------| | |
3354 // | | SubDelReq | |
3355 // | |------------->| |
3356 // | | SubDelResp | |
3357 // | |<-------------| |
3358 // | | SubDelReq | |
3359 // | |------------->| |
3360 // | | SubDelResp | |
3361 // | |<-------------| |
3362 // | RESTSubReq | | |
3363 // | [with RESTsubsId initial request] |
3364 // |---------------->| | |
3365 // | RESTSubResp | | |
3366 // |<----------------| | |
3367 // | | RouteCreate | |
3368 // | |--------------------------->|
3369 // | | RouteResponse| |
3370 // | |<---------------------------|
3372 // | |------------->| |
3374 // | |<-------------| |
3375 // | RESTNotif1 | | |
3376 // |<----------------| | |
3379 //-----------------------------------------------------------------------------
3380 func TestRESTSubReqRetransmissionV6(t *testing.T) {
3381 CaseBegin("TestRESTSubReqRetransmissionV6")
3383 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3384 Counter{cRestSubReqFromXapp, 3},
3385 Counter{cRestSubRespToXapp, 3},
3386 Counter{cSubReqToE2, 3},
3387 Counter{cSubRespFromE2, 3},
3388 Counter{cRestSubNotifToXapp, 4},
3389 Counter{cRestSubDelReqFromXapp, 2},
3390 Counter{cSubDelReqToE2, 3},
3391 Counter{cSubDelRespFromE2, 3},
3392 Counter{cRestSubDelRespToXapp, 2},
3395 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3397 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3399 <-time.After(100 * time.Millisecond)
3401 // Send modified requst, this time with e2 subscriptions.
3402 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3403 params2.SetSubscriptionID(&restSubId)
3405 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3406 xappConn1.ExpectAnyNotification(t)
3407 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3408 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3410 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3411 assert.Equal(t, e2SubsId, e2SubsId1)
3413 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3415 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3416 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3417 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3418 assert.NotEqual(t, e2SubsId2, 0)
3420 <-time.After(100 * time.Millisecond)
3422 // Delete both e2 subscriptions
3423 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3424 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3425 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3427 waitSubsCleanup(t, e2SubsId, 10)
3429 // Resend the original request, we shall find it's previous md5sum/restsubs
3430 // but the restsubscription has been already removed. This shall trigger a
3432 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
3434 <-time.After(100 * time.Millisecond)
3436 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3438 waitSubsCleanup(t, e2SubsId, 10)
3440 //Wait that subs is cleaned
3441 mainCtrl.VerifyCounterValues(t)
3444 func TestRESTSubDelReqRetransmission(t *testing.T) {
3445 CaseBegin("TestRESTSubDelReqRetransmission")
3447 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3448 Counter{cRestSubReqFromXapp, 1},
3449 Counter{cRestSubRespToXapp, 1},
3450 Counter{cSubReqToE2, 1},
3451 Counter{cSubRespFromE2, 1},
3452 Counter{cRestSubNotifToXapp, 1},
3453 Counter{cRestSubDelReqFromXapp, 2},
3454 Counter{cSubDelReqToE2, 1},
3455 Counter{cSubDelRespFromE2, 1},
3456 Counter{cRestSubDelRespToXapp, 1},
3459 var params *teststube2ap.RESTSubsReqParams = nil
3462 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3464 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3467 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3468 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3470 seqBef := mainCtrl.get_msgcounter(t)
3471 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3472 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
3474 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3476 waitSubsCleanup(t, e2SubsId, 10)
3478 mainCtrl.VerifyCounterValues(t)
3481 //-----------------------------------------------------------------------------
3482 // TestRESTSubReqDelReq
3485 // +-------+ +---------+ +---------+
3486 // | xapp | | submgr | | e2term |
3487 // +-------+ +---------+ +---------+
3490 // |---------------->| |
3492 // | RESTSubResp | |
3493 // |<----------------| |
3495 // | |------------->|
3496 // | RESTSubDelReq | |
3497 // |---------------->| |
3498 // | RESTSubDelResp | |
3500 // |<----------------| |
3502 // | |<-------------|
3504 // |<----------------| |
3506 // | [SUBS DELETE] |
3509 //-----------------------------------------------------------------------------
3510 func TestRESTSubReqDelReq(t *testing.T) {
3511 CaseBegin("TestRESTSubReqDelReq")
3513 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3514 Counter{cRestSubReqFromXapp, 1},
3515 Counter{cRestSubRespToXapp, 1},
3516 Counter{cSubReqToE2, 1},
3517 Counter{cSubRespFromE2, 1},
3518 Counter{cRestSubNotifToXapp, 1},
3519 Counter{cRestSubDelReqFromXapp, 2},
3520 Counter{cSubDelReqToE2, 1},
3521 Counter{cSubDelRespFromE2, 1},
3522 Counter{cRestSubDelRespToXapp, 1},
3525 const subReqCount int = 1
3528 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3529 restSubId := xappConn1.SendRESTSubsReq(t, params)
3531 // Del. This will fail as processing of the subscription
3532 // is still ongoing in submgr. Deletion is not allowed before
3533 // subscription creation has been completed.
3534 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3535 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3536 xappConn1.ExpectRESTNotification(t, restSubId)
3537 e2termConn1.SendSubsResp(t, crereq, cremsg)
3538 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3541 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3543 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3544 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3546 // Wait that subs is cleaned
3547 waitSubsCleanup(t, e2SubsId, 10)
3548 mainCtrl.VerifyCounterValues(t)
3552 func TestRESTSubDelReqCollision(t *testing.T) {
3553 CaseBegin("TestRESTSubDelReqCollision - not relevant for REST API")
3556 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
3557 CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel")
3559 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3560 Counter{cRestSubReqFromXapp, 2},
3561 Counter{cRestSubRespToXapp, 2},
3562 Counter{cSubReqToE2, 2},
3563 Counter{cSubRespFromE2, 2},
3564 Counter{cRestSubNotifToXapp, 2},
3565 Counter{cRestSubDelReqFromXapp, 2},
3566 Counter{cSubDelReqToE2, 2},
3567 Counter{cSubDelRespFromE2, 2},
3568 Counter{cRestSubDelRespToXapp, 2},
3572 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3573 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3574 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3577 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3578 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3579 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3581 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3582 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3584 //XappConn1 receives both of the responses
3585 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3588 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3590 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3592 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3593 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3594 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3595 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3598 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3600 deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
3602 //Wait that subs is cleaned
3603 mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
3604 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
3606 mainCtrl.VerifyCounterValues(t)
3610 func TestRESTSameSubsDiffRan(t *testing.T) {
3611 CaseBegin("TestRESTSameSubsDiffRan")
3613 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3614 Counter{cRestSubReqFromXapp, 2},
3615 Counter{cRestSubRespToXapp, 2},
3616 Counter{cSubReqToE2, 2},
3617 Counter{cSubRespFromE2, 2},
3618 Counter{cRestSubNotifToXapp, 2},
3619 Counter{cRestSubDelReqFromXapp, 2},
3620 Counter{cSubDelReqToE2, 2},
3621 Counter{cSubDelRespFromE2, 2},
3622 Counter{cRestSubDelRespToXapp, 2},
3625 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3626 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3627 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3629 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3630 params.SetMeid("RAN_NAME_2")
3631 restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
3632 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3635 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3637 deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
3639 //Wait that subs is cleaned
3640 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3641 waitSubsCleanup(t, e2SubsId2, 10)
3643 mainCtrl.VerifyCounterValues(t)
3647 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
3648 CaseBegin("TestRESTSubReqRetryInSubmgr start")
3650 // Init counter check
3651 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3652 Counter{cRestSubReqFromXapp, 1},
3653 Counter{cRestSubRespToXapp, 1},
3654 Counter{cSubReqToE2, 1},
3655 Counter{cSubReReqToE2, 1},
3656 Counter{cSubRespFromE2, 1},
3657 Counter{cRestSubNotifToXapp, 1},
3658 Counter{cRestSubDelReqFromXapp, 1},
3659 Counter{cSubDelReqToE2, 1},
3660 Counter{cSubDelRespFromE2, 1},
3661 Counter{cRestSubDelRespToXapp, 1},
3664 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3665 restSubId := xappConn1.SendRESTSubsReq(t, params)
3667 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3669 // Catch the first message and ignore it
3670 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3671 xapp.Logger.Debug("Ignore REST subscriber request for subscriber : %v", restSubId)
3673 // The second request is being handled normally
3674 crereq, cremsg = e2termConn1.RecvSubsReq(t)
3675 xappConn1.ExpectRESTNotification(t, restSubId)
3676 e2termConn1.SendSubsResp(t, crereq, cremsg)
3677 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3679 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3681 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3683 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
3684 //Wait that subs is cleaned
3685 waitSubsCleanup(t, e2SubsId, 10)
3687 mainCtrl.VerifyCounterValues(t)
3691 //-----------------------------------------------------------------------------
3692 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3695 // +-------+ +---------+ +---------+
3696 // | xapp | | submgr | | e2term |
3697 // +-------+ +---------+ +---------+
3700 // |---------------->| |
3702 // | RESTSubResp | |
3703 // |<----------------| |
3705 // | |------------->|
3709 // | |------------->|
3712 // | |------------->|
3716 // | |------------->|
3720 // | |<-------------|
3723 // |<----------------| |
3725 // | [SUBS DELETE] |
3728 //-----------------------------------------------------------------------------
3730 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
3731 CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
3733 // Init counter check
3734 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3735 Counter{cRestSubReqFromXapp, 1},
3736 Counter{cRestSubRespToXapp, 1},
3737 Counter{cSubReqToE2, 1},
3738 Counter{cSubReReqToE2, 1},
3739 Counter{cSubReqTimerExpiry, 2},
3740 Counter{cSubDelReqToE2, 1},
3741 Counter{cSubDelRespFromE2, 1},
3744 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3745 restSubId := xappConn1.SendRESTSubsReq(t, params)
3746 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3748 e2termConn1.RecvSubsReq(t)
3749 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3751 e2termConn1.RecvSubsReq(t)
3752 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3754 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3755 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3756 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3757 xappConn1.WaitRESTNotification(t, restSubId)
3759 // Wait that subs is cleaned
3760 waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
3762 mainCtrl.VerifyCounterValues(t)
3765 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
3766 CaseBegin("TestREST2eTermNotRespondingToSubReq start")
3768 // Init counter check
3769 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3770 Counter{cRestSubReqFromXapp, 1},
3771 Counter{cRestSubRespToXapp, 1},
3772 Counter{cSubReqToE2, 1},
3773 Counter{cSubReReqToE2, 1},
3774 Counter{cSubReqTimerExpiry, 2},
3775 Counter{cSubDelReqToE2, 1},
3776 Counter{cSubDelReqTimerExpiry, 2},
3779 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3780 restSubId := xappConn1.SendRESTSubsReq(t, params)
3781 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3783 e2termConn1.RecvSubsReq(t)
3784 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3786 e2termConn1.RecvSubsReq(t)
3787 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3789 e2termConn1.RecvSubsDelReq(t)
3790 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3792 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3793 e2termConn1.RecvSubsDelReq(t)
3794 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3796 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3798 waitSubsCleanup(t, e2SubsId, 10)
3800 mainCtrl.VerifyCounterValues(t)
3804 //-----------------------------------------------------------------------------
3805 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3808 // +-------+ +---------+ +---------+
3809 // | xapp | | submgr | | e2term |
3810 // +-------+ +---------+ +---------+
3813 // |---------------->| |
3815 // | RESTSubResp | |
3816 // |<----------------| |
3818 // | |------------->|
3822 // | |------------->|
3825 // | |------------->|
3829 // | |------------->|
3833 // | |<-------------|
3836 // |<----------------| |
3838 // | [SUBS DELETE] |
3841 //-----------------------------------------------------------------------------
3842 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
3843 CaseBegin("TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr start")
3845 // Init counter check
3846 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3847 Counter{cRestSubReqFromXapp, 1},
3848 Counter{cRestSubRespToXapp, 1},
3849 Counter{cSubReqToE2, 1},
3850 Counter{cSubReReqToE2, 1},
3851 Counter{cSubReqTimerExpiry, 2},
3852 Counter{cSubDelReqToE2, 1},
3853 Counter{cSubDelReReqToE2, 1},
3854 Counter{cSubDelReqTimerExpiry, 2},
3857 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3858 restSubId := xappConn1.SendRESTSubsReq(t, params)
3859 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3861 e2termConn1.RecvSubsReq(t)
3862 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3864 e2termConn1.RecvSubsReq(t)
3865 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3867 e2termConn1.RecvSubsDelReq(t)
3868 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3870 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3871 e2termConn1.RecvSubsDelReq(t)
3872 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3874 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3876 waitSubsCleanup(t, e2SubsId, 10)
3878 mainCtrl.VerifyCounterValues(t)
3881 //-----------------------------------------------------------------------------
3882 // TestRESTSubReqSubFailRespInSubmgr
3885 // +-------+ +---------+ +---------+
3886 // | xapp | | submgr | | e2term |
3887 // +-------+ +---------+ +---------+
3890 // |---------------->| |
3892 // | RESTSubResp | |
3893 // |<----------------| |
3895 // | |------------->|
3898 // | |<-------------|
3902 // |<----------------| |
3904 // | [SUBS DELETE] |
3907 //-----------------------------------------------------------------------------
3908 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
3909 CaseBegin("TestRESTSubReqSubFailRespInSubmgr")
3911 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3912 Counter{cRestSubReqFromXapp, 1},
3913 Counter{cRestSubRespToXapp, 1},
3914 Counter{cSubReqToE2, 1},
3915 Counter{cSubFailFromE2, 1},
3916 Counter{cRestSubFailNotifToXapp, 1},
3917 Counter{cRestSubDelReqFromXapp, 1},
3920 const subReqCount int = 1
3921 const e2Timeout int64 = 2
3922 const e2RetryCount int64 = 1
3923 const routingNeeded bool = true
3925 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3926 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
3927 restSubId := xappConn1.SendRESTSubsReq(t, params)
3929 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3930 fparams1 := &teststube2ap.E2StubSubsFailParams{}
3931 fparams1.Set(crereq1)
3932 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3933 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3935 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3936 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
3938 // REST subscription sill there to be deleted
3939 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3941 // Wait that subs is cleaned
3942 waitSubsCleanup(t, e2SubsId, 10)
3944 mainCtrl.VerifyCounterValues(t)
3948 //-----------------------------------------------------------------------------
3949 // TestRESTSubDelReqRetryInSubmgr
3952 // +-------+ +---------+ +---------+
3953 // | xapp | | submgr | | e2term |
3954 // +-------+ +---------+ +---------+
3956 // | [SUBS CREATE] |
3959 // | RESTSubDelReq | |
3960 // |---------------->| |
3962 // | RESTSubDelResp | |
3963 // |<----------------| |
3965 // | |------------->|
3968 // | |------------->|
3971 // | |<-------------|
3974 //-----------------------------------------------------------------------------
3975 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
3976 CaseBegin("TestRESTSubDelReqRetryInSubmgr")
3978 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3979 Counter{cRestSubReqFromXapp, 1},
3980 Counter{cRestSubRespToXapp, 1},
3981 Counter{cSubReqToE2, 1},
3982 Counter{cSubRespFromE2, 1},
3983 Counter{cRestSubNotifToXapp, 1},
3984 Counter{cRestSubDelReqFromXapp, 1},
3985 Counter{cSubDelReqToE2, 1},
3986 Counter{cSubDelReReqToE2, 1},
3987 Counter{cSubDelRespFromE2, 1},
3988 Counter{cRestSubDelRespToXapp, 1},
3991 var params *teststube2ap.RESTSubsReqParams = nil
3992 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3995 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3997 // E2t: Receive 1st SubsDelReq
3998 e2termConn1.RecvSubsDelReq(t)
4000 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4001 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4002 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4004 //Wait that subs is cleaned
4005 waitSubsCleanup(t, e2SubsId, 10)
4007 mainCtrl.VerifyCounterValues(t)
4010 //-----------------------------------------------------------------------------
4011 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
4014 // +-------+ +---------+ +---------+
4015 // | xapp | | submgr | | e2term |
4016 // +-------+ +---------+ +---------+
4018 // | [SUBS CREATE] |
4021 // | RESTSubDelReq | |
4022 // |---------------->| |
4024 // | RESTSubDelResp | |
4025 // |<----------------| |
4027 // | |------------->|
4030 // | |------------->|
4034 //-----------------------------------------------------------------------------
4035 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
4036 CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr")
4038 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4039 Counter{cRestSubReqFromXapp, 1},
4040 Counter{cRestSubRespToXapp, 1},
4041 Counter{cSubReqToE2, 1},
4042 Counter{cSubRespFromE2, 1},
4043 Counter{cRestSubNotifToXapp, 1},
4044 Counter{cRestSubDelReqFromXapp, 1},
4045 Counter{cSubDelReqToE2, 1},
4046 Counter{cSubDelReReqToE2, 1},
4047 Counter{cSubDelRespFromE2, 1},
4048 Counter{cRestSubDelRespToXapp, 1},
4052 var params *teststube2ap.RESTSubsReqParams = nil
4053 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4056 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4058 // E2t: Receive 1st SubsDelReq
4059 e2termConn1.RecvSubsDelReq(t)
4061 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4062 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4063 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4065 //Wait that subs is cleaned
4066 waitSubsCleanup(t, e2SubsId, 10)
4068 mainCtrl.VerifyCounterValues(t)
4071 //-----------------------------------------------------------------------------
4072 // TestRESTSubDelReqSubDelFailRespInSubmgr
4075 // +-------+ +---------+ +---------+
4076 // | xapp | | submgr | | e2term |
4077 // +-------+ +---------+ +---------+
4079 // | [SUBS CREATE] |
4082 // | RESTSubDelReq | |
4083 // |---------------->| |
4085 // | RESTSubDelResp | |
4086 // |<----------------| |
4088 // | |------------->|
4091 // | |<-------------|
4094 //-----------------------------------------------------------------------------
4095 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
4096 CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr")
4098 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4099 Counter{cRestSubReqFromXapp, 1},
4100 Counter{cRestSubRespToXapp, 1},
4101 Counter{cSubReqToE2, 1},
4102 Counter{cSubRespFromE2, 1},
4103 Counter{cRestSubNotifToXapp, 1},
4104 Counter{cRestSubDelReqFromXapp, 1},
4105 Counter{cSubDelReqToE2, 1},
4106 Counter{cSubDelFailFromE2, 1},
4107 Counter{cRestSubDelRespToXapp, 1},
4111 var params *teststube2ap.RESTSubsReqParams = nil
4112 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4115 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4117 // E2t: Send receive SubsDelReq and send SubsDelFail
4118 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4119 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
4121 //Wait that subs is cleaned
4122 waitSubsCleanup(t, e2SubsId, 10)
4124 mainCtrl.VerifyCounterValues(t)
4127 //-----------------------------------------------------------------------------
4128 // TestRESTSubReqAndSubDelOkSameAction
4131 // +-------+ +-------+ +---------+ +---------+
4132 // | xapp2 | | xapp1 | | submgr | | e2term |
4133 // +-------+ +-------+ +---------+ +---------+
4135 // | | RESTSubReq1 | |
4136 // | |---------------->| |
4138 // | | RESTSubResp1 | |
4139 // | |<----------------| |
4142 // | | |------------->|
4144 // | | |<-------------|
4145 // | | RESTNotif1 | |
4146 // | |<----------------| |
4148 // | RESTSubReq2 | |
4149 // |------------------------------>| |
4151 // | RESTSubResp2 | |
4152 // |<------------------------------| |
4154 // | | RESTNotif2 | |
4155 // |<------------------------------| |
4157 // | | RESTSubDelReq1 | |
4158 // | |---------------->| |
4160 // | | RESTSubDelResp1 | |
4161 // | |<----------------| |
4163 // | RESTSubDelReq2 | |
4164 // |------------------------------>| |
4166 // | RESTSubDelResp2 | |
4167 // |<------------------------------| |
4169 // | | | SubDelReq2 |
4170 // | | |------------->|
4172 // | | | SubDelResp2 |
4173 // | | |<-------------|
4176 //-----------------------------------------------------------------------------
4177 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
4178 CaseBegin("TestRESTSubReqAndSubDelOkSameAction")
4180 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4181 Counter{cRestSubReqFromXapp, 2},
4182 Counter{cRestSubRespToXapp, 2},
4183 Counter{cSubReqToE2, 1},
4184 Counter{cSubRespFromE2, 1},
4185 Counter{cRestSubNotifToXapp, 2},
4186 Counter{cMergedSubscriptions, 1},
4187 Counter{cUnmergedSubscriptions, 1},
4188 Counter{cRestSubDelReqFromXapp, 2},
4189 Counter{cSubDelReqToE2, 1},
4190 Counter{cSubDelRespFromE2, 1},
4191 Counter{cRestSubDelRespToXapp, 2},
4195 var params *teststube2ap.RESTSubsReqParams = nil
4198 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4199 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4202 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4203 params.SetMeid("RAN_NAME_1")
4205 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4206 xappConn2.ExpectAnyNotification(t)
4207 waiter := rtmgrHttp.AllocNextSleep(10, true)
4208 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4209 waiter.WaitResult(t)
4210 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
4211 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
4212 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
4214 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
4217 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4220 deleteXapp2Subscription(t, &restSubId2)
4222 //Wait that subs is cleaned
4223 waitSubsCleanup(t, e2SubsId2, 10)
4225 mainCtrl.VerifyCounterValues(t)
4228 //-----------------------------------------------------------------------------
4229 // TestSubReqAndSubDelOkSameActionParallel
4232 // +-------+ +-------+ +---------+ +---------+
4233 // | xapp2 | | xapp1 | | submgr | | e2term |
4234 // +-------+ +-------+ +---------+ +---------+
4239 // | |------------->| |
4242 // | | |------------->|
4244 // |--------------------------->| |
4246 // | | |<-------------|
4248 // | |<-------------| |
4250 // | | |------------->|
4253 // | | |<-------------|
4255 // |<---------------------------| |
4257 // | | SubDelReq 1 | |
4258 // | |------------->| |
4260 // | | SubDelResp 1 | |
4261 // | |<-------------| |
4263 // | SubDelReq 2 | |
4264 // |--------------------------->| |
4266 // | | | SubDelReq 2 |
4267 // | | |------------->|
4269 // | | | SubDelReq 2 |
4270 // | | |------------->|
4272 // | SubDelResp 2 | |
4273 // |<---------------------------| |
4275 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
4276 CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel")
4278 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4279 Counter{cRestSubReqFromXapp, 2},
4280 Counter{cRestSubRespToXapp, 2},
4281 Counter{cSubReqToE2, 2},
4282 Counter{cSubRespFromE2, 2},
4283 Counter{cRestSubNotifToXapp, 2},
4284 Counter{cRestSubDelReqFromXapp, 2},
4285 Counter{cSubDelReqToE2, 2},
4286 Counter{cSubDelRespFromE2, 2},
4287 Counter{cRestSubDelRespToXapp, 2},
4290 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4291 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4292 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4294 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4295 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4297 xappConn1.ExpectRESTNotification(t, restSubId1)
4298 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4299 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4301 xappConn2.ExpectRESTNotification(t, restSubId2)
4302 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
4303 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
4304 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4307 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4308 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4309 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4310 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4313 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4314 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
4315 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
4317 waitSubsCleanup(t, e2SubsId2, 10)
4319 mainCtrl.VerifyCounterValues(t)
4322 //-----------------------------------------------------------------------------
4323 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
4326 // +-------+ +-------+ +---------+ +---------+
4327 // | xapp2 | | xapp1 | | submgr | | e2term |
4328 // +-------+ +-------+ +---------+ +---------+
4332 // | | RESTSubReq1 | |
4333 // | |---------------->| |
4335 // | | RESTSubResp1 | |
4336 // | |<----------------| |
4338 // | | |------------->|
4339 // | RESTSubReq2 | |
4340 // |------------------------------>| |
4342 // | RESTSubDelResp2 | |
4343 // |<------------------------------| |
4345 // | | |------------->|
4348 // | | | SubDelReq |
4349 // | | |------------->|
4351 // | | | SubDelResp |
4352 // | | |<-------------|
4353 // | | RESTNotif1 | |
4354 // | | unsuccess | |
4355 // | |<----------------| |
4357 // | | unsuccess | |
4358 // |<------------------------------| |
4360 // | | RESTSubDelReq1 | |
4361 // | |---------------->| |
4363 // | | RESTSubDelResp1 | |
4364 // | |<----------------| |
4366 // | RESTSubDelReq2 | |
4367 // |------------------------------>| |
4369 // | RESTSubDelResp2 | |
4370 // |<------------------------------| |
4372 //-----------------------------------------------------------------------------
4373 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
4374 CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
4376 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4377 Counter{cRestSubReqFromXapp, 2},
4378 Counter{cRestSubRespToXapp, 2},
4379 Counter{cSubReqToE2, 1},
4380 Counter{cRestSubFailNotifToXapp, 2},
4381 Counter{cRestSubDelReqFromXapp, 2},
4382 Counter{cSubDelReqToE2, 1},
4383 Counter{cSubDelRespFromE2, 1},
4384 Counter{cRestSubDelRespToXapp, 2},
4387 const subReqCount int = 1
4390 params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4391 restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
4392 crereq1, _ := e2termConn1.RecvSubsReq(t)
4395 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4396 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4397 params2.SetMeid("RAN_NAME_1")
4398 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4399 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4401 //Req1 (retransmitted)
4402 e2termConn1.RecvSubsReq(t)
4404 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4406 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4407 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4409 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4410 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4411 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4412 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4415 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4418 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4420 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
4422 //Wait that subs is cleaned
4423 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4425 mainCtrl.VerifyCounterValues(t)
4428 //-----------------------------------------------------------------------------
4429 // TestRESTSubReqAndSubDelNokSameActionParallel
4432 // +-------+ +-------+ +---------+ +---------+
4433 // | xapp2 | | xapp1 | | submgr | | e2term |
4434 // +-------+ +-------+ +---------+ +---------+
4438 // | | RESTSubReq1 | |
4439 // | |---------------->| |
4441 // | | RESTSubResp1 | |
4442 // | |<----------------| |
4444 // | | |------------->|
4445 // | RESTSubReq2 | |
4446 // |------------------------------>| |
4448 // | RESTSubDelResp2 | |
4449 // |<------------------------------| |
4451 // | | |<-------------|
4453 // | | RESTNotif1 | |
4454 // | | unsuccess | |
4455 // | |<----------------| |
4457 // | | unsuccess | |
4458 // |<------------------------------| |
4460 // | | RESTSubDelReq1 | | There is no need for xApp to send delete for failed subscriptions but some xApp might do so.
4461 // | |---------------->| |
4463 // | | RESTSubDelResp1 | |
4464 // | |<----------------| |
4466 // | RESTSubDelReq2 | |
4467 // |------------------------------>| |
4469 // | RESTSubDelResp2 | |
4470 // |<------------------------------| |
4472 //-----------------------------------------------------------------------------
4473 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
4474 CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
4476 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4477 Counter{cRestSubReqFromXapp, 2},
4478 Counter{cRestSubRespToXapp, 2},
4479 Counter{cSubReqToE2, 1},
4480 Counter{cSubFailFromE2, 1},
4481 Counter{cRestSubFailNotifToXapp, 2},
4482 Counter{cRestSubDelReqFromXapp, 2},
4483 Counter{cRestSubDelRespToXapp, 2},
4486 const subReqCount int = 1
4489 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4490 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4491 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4494 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4495 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4496 params2.SetMeid("RAN_NAME_1")
4497 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4498 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4500 // E2t: send SubsFail (first)
4501 fparams1 := &teststube2ap.E2StubSubsFailParams{}
4502 fparams1.Set(crereq1)
4503 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
4505 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4506 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4507 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4508 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4509 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4512 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4515 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4517 //Wait that subs is cleaned
4518 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4519 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
4521 mainCtrl.VerifyCounterValues(t)
4524 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
4525 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4527 // Init counter check
4528 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4529 Counter{cRestSubReqFromXapp, 1},
4530 Counter{cRestSubRespToXapp, 1},
4531 Counter{cSubReqToE2, 1},
4532 Counter{cSubRespFromE2, 1},
4533 Counter{cRestSubNotifToXapp, 1},
4534 Counter{cRestSubDelReqFromXapp, 1},
4535 Counter{cSubDelReqToE2, 1},
4536 Counter{cSubDelRespFromE2, 1},
4537 Counter{cRestSubDelRespToXapp, 1},
4540 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4541 restSubId := xappConn1.SendRESTSubsReq(t, params)
4542 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
4544 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4545 xappConn1.ExpectRESTNotification(t, restSubId)
4546 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4547 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4548 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
4550 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4551 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4552 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4554 // Wait that subs is cleaned
4555 waitSubsCleanup(t, e2SubsId, 10)
4556 mainCtrl.VerifyCounterValues(t)
4559 //-----------------------------------------------------------------------------
4560 // TestRESTSubReqPolicyChangeAndSubDelOk
4563 // +-------+ +---------+ +---------+
4564 // | xapp | | submgr | | e2term |
4565 // +-------+ +---------+ +---------+
4568 // |---------------->| |
4570 // | RESTSubResp | |
4571 // |<----------------| |
4573 // | |------------->|
4576 // | |<-------------|
4579 // |<----------------| |
4582 // |---------------->| |
4584 // | RESTSubResp | |
4585 // |<----------------| |
4587 // | |------------->|
4590 // | |<-------------|
4593 // |<----------------| |
4595 // | RESTSubDelReq | |
4596 // |---------------->| |
4599 // | |------------->|
4602 // | |<-------------|
4604 // | RESTSubDelResp | |
4605 // |<----------------| |
4607 //-----------------------------------------------------------------------------
4608 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
4609 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4611 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4612 Counter{cRestSubReqFromXapp, 2},
4613 Counter{cRestSubRespToXapp, 2},
4614 Counter{cSubReqToE2, 2},
4615 Counter{cSubRespFromE2, 2},
4616 Counter{cRestSubNotifToXapp, 2},
4617 Counter{cRestSubDelReqFromXapp, 1},
4618 Counter{cSubDelReqToE2, 1},
4619 Counter{cSubDelRespFromE2, 1},
4620 Counter{cRestSubDelRespToXapp, 1},
4623 const subReqCount int = 1
4624 const e2Timeout int64 = 1
4625 const e2RetryCount int64 = 0
4626 const routingNeeded bool = true
4629 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4630 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4631 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4634 // GetRESTSubsReqPolicyParams sets some counters on tc side.
4636 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4637 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4638 params.SetSubscriptionID(&restSubId)
4639 params.SetTimeToWait("w200ms")
4640 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
4643 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4645 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4646 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4648 // Wait that subs is cleaned
4649 waitSubsCleanup(t, e2SubsId, 10)
4650 mainCtrl.VerifyCounterValues(t)
4653 //-----------------------------------------------------------------------------
4654 // TestRESTSubReqPolicyChangeNOk
4657 // +-------+ +---------+ +---------+
4658 // | xapp | | submgr | | e2term |
4659 // +-------+ +---------+ +---------+
4662 // |---------------->| |
4664 // | RESTSubResp | |
4665 // |<----------------| |
4667 // | |------------->|
4670 // | |<-------------|
4673 // |<----------------| |
4676 // |---------------->| |
4678 // | RESTSubUpdateFail(400 Bad request)
4680 // | RESTSubDelReq | |
4681 // |---------------->| |
4684 // | |------------->|
4687 // | |<-------------|
4689 // | RESTSubDelResp | |
4690 // |<----------------| |
4692 //-----------------------------------------------------------------------------
4693 func TestRESTSubReqPolicyChangeNOk(t *testing.T) {
4694 CaseBegin("TestRESTSubReqPolicyChangeNOk")
4696 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4697 Counter{cRestSubReqFromXapp, 2},
4698 Counter{cRestSubRespToXapp, 1},
4699 Counter{cSubReqToE2, 1},
4700 Counter{cSubRespFromE2, 1},
4701 Counter{cRestSubNotifToXapp, 1},
4702 Counter{cRestSubFailToXapp, 1},
4703 Counter{cRestSubDelReqFromXapp, 1},
4704 Counter{cSubDelReqToE2, 1},
4705 Counter{cSubDelRespFromE2, 1},
4706 Counter{cRestSubDelRespToXapp, 1},
4710 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4711 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4714 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4716 restSubIdUpd := strings.ToUpper(restSubId) // This makes RESTSubReq to fail
4717 params.SetSubscriptionID(&restSubIdUpd)
4718 params.SetTimeToWait("w200ms")
4720 restSubId2 := xappConn1.SendRESTSubsReq(t, params)
4721 assert.Equal(t, restSubId2, "")
4724 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4726 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4727 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4729 // Wait that subs is cleaned
4730 waitSubsCleanup(t, e2SubsId, 10)
4731 mainCtrl.VerifyCounterValues(t)
4734 //-----------------------------------------------------------------------------
4735 // TestRESTSubReqAndSubDelOkTwoE2termParallel
4738 // +-------+ +---------+ +---------+ +---------+
4739 // | xapp | | submgr | | e2term1 | | e2term2 |
4740 // +-------+ +---------+ +---------+ +---------+
4744 // | RESTSubReq1 | | |
4745 // |---------------->| | |
4747 // | RESTSubResp1 | | |
4748 // |<----------------| | |
4750 // | |------------->| |
4752 // | RESTSubReq2 | | |
4753 // |---------------->| | |
4755 // | RESTSubResp2 | | |
4756 // |<----------------| | |
4758 // | |---------------------------->|
4761 // | |<-------------| |
4762 // | RESTNotif1 | | |
4763 // |<----------------| | |
4765 // | |<----------------------------|
4766 // | RESTNotif2 | | |
4767 // |<----------------| | |
4769 // | [SUBS 1 DELETE] | |
4771 // | [SUBS 2 DELETE] | |
4774 //-----------------------------------------------------------------------------
4775 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
4776 CaseBegin("TestRESTSubReqAndSubDelOkTwoE2termParallel")
4778 // Init counter check
4779 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4780 Counter{cRestSubReqFromXapp, 2},
4781 Counter{cRestSubRespToXapp, 2},
4782 Counter{cSubReqToE2, 2},
4783 Counter{cSubRespFromE2, 2},
4784 Counter{cRestSubNotifToXapp, 2},
4785 Counter{cRestSubDelReqFromXapp, 2},
4786 Counter{cSubDelReqToE2, 2},
4787 Counter{cSubDelRespFromE2, 2},
4788 Counter{cRestSubDelRespToXapp, 2},
4791 const subReqCount int = 1
4794 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4795 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4796 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4799 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4800 params.SetMeid("RAN_NAME_11")
4801 // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
4802 // would not work as notification would not be received
4803 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4804 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
4807 xappConn1.ExpectRESTNotification(t, restSubId1)
4808 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4809 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4810 xapp.Logger.Debug("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
4813 xappConn2.ExpectRESTNotification(t, restSubId2)
4814 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
4815 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4816 xapp.Logger.Debug("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
4819 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4820 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4821 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4823 // Wait that subs is cleaned
4824 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4827 xappConn1.SendRESTSubsDelReq(t, &restSubId2)
4828 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
4829 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
4831 // Wait that subs is cleaned
4832 waitSubsCleanup(t, e2SubsId2, 10)
4834 mainCtrl.VerifyCounterValues(t)
4837 //-----------------------------------------------------------------------------
4838 // TestRESTSubReqAsn1EncodeFail
4840 // In this case submgr send RICSubscriptionDeleteRequest after encode failure which should not happen!
4842 // +-------+ +---------+ +---------+
4843 // | xapp | | submgr | | e2term |
4844 // +-------+ +---------+ +---------+
4847 // |---------------->| |
4849 // | RESTSubResp | |
4850 // |<----------------| |
4851 // | RESTSubDelReq | |
4852 // |---------------->| |
4853 // | RESTSubDelResp | |
4855 // |<----------------| |
4858 //-----------------------------------------------------------------------------
4859 func TestRESTSubReqAsn1EncodeFail(t *testing.T) {
4860 CaseBegin("TestRESTSubReqAsn1EncodeFail")
4862 xapp.Logger.Debug("Xapp-frame, v0.8.1 sufficient REST API validation")
4866 //-----------------------------------------------------------------------------
4867 // TestRESTSubReqInsertAndSubDelOk
4870 // +-------+ +---------+ +---------+
4871 // | xapp | | submgr | | e2term |
4872 // +-------+ +---------+ +---------+
4875 // |---------------->| |
4877 // | RESTSubResp | |
4878 // |<----------------| |
4881 // | |------------->|
4884 // | |<-------------|
4886 // |<----------------| |
4889 // | RESTSubDelReq | |
4890 // |---------------->| |
4893 // | |------------->|
4896 // | |<-------------|
4898 // | RESTSubDelResp| |
4899 // |<----------------| |
4901 //-----------------------------------------------------------------------------
4902 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
4903 CaseBegin("TestRESTInsertSubReqAndSubDelOk")
4905 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4906 Counter{cRestSubReqFromXapp, 1},
4907 Counter{cRestSubRespToXapp, 1},
4908 Counter{cSubReqToE2, 1},
4909 Counter{cSubRespFromE2, 1},
4910 Counter{cRestSubNotifToXapp, 1},
4911 Counter{cRestSubDelReqFromXapp, 1},
4912 Counter{cSubDelReqToE2, 1},
4913 Counter{cSubDelRespFromE2, 1},
4914 Counter{cRestSubDelRespToXapp, 1},
4917 const subReqCount int = 1
4919 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4920 params.SetSubActionTypes("insert")
4923 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4926 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4928 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4929 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4931 // Wait that subs is cleaned
4932 waitSubsCleanup(t, e2SubsId, 10)
4933 mainCtrl.VerifyCounterValues(t)
4936 //-----------------------------------------------------------------------------
4937 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
4940 // +-------+ +---------+ +---------+
4941 // | xapp | | submgr | | e2term |
4942 // +-------+ +---------+ +---------+
4945 // |------------->| |
4948 // | |------------->|
4953 // | Submgr restart |
4957 // | |------------->|
4960 // | |<-------------|
4963 //-----------------------------------------------------------------------------
4964 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
4965 CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle")
4967 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4968 Counter{cRestSubReqFromXapp, 1},
4969 Counter{cRestSubRespToXapp, 1},
4970 Counter{cSubReqToE2, 1},
4971 Counter{cSubDelReqFromXapp, 1},
4972 Counter{cSubDelReqToE2, 1},
4973 Counter{cSubDelRespFromE2, 1},
4976 const subReqCount int = 1
4978 // Remove possible existing subscription
4979 mainCtrl.removeExistingSubscriptions(t)
4981 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4984 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
4985 restSubId := xappConn1.SendRESTSubsReq(t, params)
4986 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
4988 e2termConn1.RecvSubsReq(t)
4990 mainCtrl.SetResetTestFlag(t, false)
4992 mainCtrl.SimulateRestart(t)
4993 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4996 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4997 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4999 xappConn1.TestMsgChanEmpty(t)
5000 xappConn2.TestMsgChanEmpty(t)
5001 e2termConn1.TestMsgChanEmpty(t)
5002 mainCtrl.wait_registry_empty(t, 10)
5004 mainCtrl.VerifyCounterValues(t)
5007 //-----------------------------------------------------------------------------
5008 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
5011 // +-------+ +---------+ +---------+
5012 // | xapp | | submgr | | e2term |
5013 // +-------+ +---------+ +---------+
5016 // |---------------->| |
5018 // | RESTSubResp | |
5019 // |<----------------| |
5021 // | |------------->|
5024 // | |<-------------|
5027 // |<----------------| |
5030 // | Submgr restart |
5032 // | RESTSubDelReq | |
5033 // |---------------->| |
5036 // | |------------->|
5039 // | |<-------------|
5041 // | RESTSubDelResp | |
5042 // |<----------------| |
5044 //-----------------------------------------------------------------------------
5046 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
5047 CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle")
5049 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5050 Counter{cRestSubReqFromXapp, 1},
5051 Counter{cRestSubRespToXapp, 1},
5052 Counter{cSubReqToE2, 1},
5053 Counter{cSubRespFromE2, 1},
5054 Counter{cRestSubNotifToXapp, 1},
5055 Counter{cRestSubDelReqFromXapp, 1},
5056 Counter{cSubDelReqToE2, 1},
5057 Counter{cRestSubDelRespToXapp, 1},
5060 // Remove possible existing subscription
5061 mainCtrl.removeExistingSubscriptions(t)
5063 var params *teststube2ap.RESTSubsReqParams = nil
5065 // Create subscription
5066 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5067 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5069 // Check subscription
5070 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5072 mainCtrl.SimulateRestart(t)
5073 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5075 // Check subscription
5076 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5078 // Delete subscription
5079 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
5081 //Wait that subs is cleaned
5082 waitSubsCleanup(t, e2SubsId, 10)
5084 mainCtrl.VerifyCounterValues(t)
5087 //-----------------------------------------------------------------------------
5088 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
5091 // +-------+ +-------+ +---------+ +---------+
5092 // | xapp2 | | xapp1 | | submgr | | e2term |
5093 // +-------+ +-------+ +---------+ +---------+
5095 // | | RESTSubReq1 | |
5096 // | |---------------->| |
5098 // | | RESTSubResp1 | |
5099 // | |<----------------| |
5102 // | | |------------->|
5104 // | | |<-------------|
5105 // | | RESTNotif1 | |
5106 // | |<----------------| |
5108 // | RESTSubReq2 | |
5109 // |------------------------------>| |
5111 // | RESTSubResp2 | |
5112 // |<------------------------------| |
5114 // | | RESTNotif2 | |
5115 // |<------------------------------| |
5117 // | | Submgr restart |
5119 // | | RESTSubDelReq1 | |
5120 // | |---------------->| |
5122 // | | RESTSubDelResp1 | |
5123 // | |<----------------| |
5125 // | | Submgr restart |
5127 // | RESTSubDelReq2 | |
5128 // |------------------------------>| |
5130 // | RESTSubDelResp2 | |
5131 // |<------------------------------| |
5133 // | | | SubDelReq2 |
5134 // | | |------------->|
5136 // | | | SubDelResp2 |
5137 // | | |<-------------|
5140 //-----------------------------------------------------------------------------
5142 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
5143 CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
5145 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5146 Counter{cRestSubReqFromXapp, 2},
5147 Counter{cRestSubRespToXapp, 2},
5148 Counter{cSubReqToE2, 1},
5149 Counter{cSubRespFromE2, 1},
5150 Counter{cRestSubNotifToXapp, 2},
5151 Counter{cMergedSubscriptions, 1},
5152 Counter{cUnmergedSubscriptions, 1},
5153 Counter{cRestSubDelReqFromXapp, 2},
5154 Counter{cSubDelReqToE2, 1},
5155 Counter{cSubDelRespFromE2, 1},
5156 Counter{cRestSubDelRespToXapp, 2},
5159 // Remove possible existing subscription
5160 mainCtrl.removeExistingSubscriptions(t)
5162 var params *teststube2ap.RESTSubsReqParams = nil
5164 // Create subscription 1
5165 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5166 xapp.Logger.Debug("Send REST subscriber request for subscriber 1 : %v", restSubId1)
5168 // Create subscription 2 with same action
5169 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5170 params.SetMeid("RAN_NAME_1")
5171 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
5172 xappConn2.ExpectAnyNotification(t)
5173 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5174 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5175 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
5176 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
5178 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
5180 mainCtrl.SimulateRestart(t)
5181 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5183 // Delete subscription 1, and wait until it has removed the first endpoint
5184 subepcnt := mainCtrl.get_subs_entrypoint_cnt(t, e2SubsId1)
5185 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5186 mainCtrl.wait_subs_entrypoint_cnt_change(t, e2SubsId1, subepcnt, 10)
5188 mainCtrl.SimulateRestart(t)
5189 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5190 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
5192 // Delete subscription 2
5193 deleteXapp2Subscription(t, &restSubId2)
5195 //Wait that subs is cleaned
5196 waitSubsCleanup(t, e2SubsId2, 10)
5198 mainCtrl.VerifyCounterValues(t)
5201 //-----------------------------------------------------------------------------
5202 // TestRESTReportSubReqAndSubDelOk
5205 // +-------+ +---------+ +---------+
5206 // | xapp | | submgr | | e2term |
5207 // +-------+ +---------+ +---------+
5210 // |---------------->| |
5212 // | RESTSubResp | |
5213 // |<----------------| |
5216 // | |------------->|
5219 // | |<-------------|
5221 // |<----------------| |
5223 // | |------------->|
5226 // | |<-------------|
5228 // |<----------------| |
5232 // | RESTSubDelReq | |
5233 // |---------------->| |
5236 // | |------------->|
5239 // | |<-------------|
5241 // | RESTSubDelResp| |
5242 // |<----------------| |
5244 //-----------------------------------------------------------------------------
5246 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
5247 CaseBegin("TestRESTReportSubReqAndSubDelOk")
5248 const subReqCount int = 1
5250 RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
5253 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5254 xapp.Logger.Debug("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
5257 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5258 restSubId := xappConn1.SendRESTSubsReq(t, params)
5260 var e2SubsId []uint32
5261 for i := 0; i < subReqCount; i++ {
5262 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5263 xappConn1.ExpectRESTNotification(t, restSubId)
5265 e2termConn1.SendSubsResp(t, crereq, cremsg)
5266 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5267 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5268 e2SubsId = append(e2SubsId, instanceId)
5269 resp, _ := xapp.Subscription.QuerySubscriptions()
5270 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
5271 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
5272 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
5277 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5279 for i := 0; i < subReqCount; i++ {
5280 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5281 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5284 // Wait that subs is cleaned
5285 for i := 0; i < subReqCount; i++ {
5286 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5289 xappConn1.TestMsgChanEmpty(t)
5290 e2termConn1.TestMsgChanEmpty(t)
5291 mainCtrl.wait_registry_empty(t, 10)
5295 func TestRESTPolicySubReqAndSubDelOk(t *testing.T) {
5296 CaseBegin("TestRESTPolicySubReqAndSubDelOk")
5300 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5304 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5307 func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5308 xapp.Logger.Debug("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
5311 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5312 restSubId := xappConn1.SendRESTSubsReq(t, params)
5314 var e2SubsId []uint32
5315 for i := 0; i < subReqCount; i++ {
5316 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5317 xappConn1.ExpectRESTNotification(t, restSubId)
5318 e2termConn1.SendSubsResp(t, crereq, cremsg)
5319 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5320 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5321 e2SubsId = append(e2SubsId, instanceId)
5325 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5327 for i := 0; i < subReqCount; i++ {
5328 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5329 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5332 // Wait that subs is cleaned
5333 for i := 0; i < subReqCount; i++ {
5334 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5336 xappConn1.TestMsgChanEmpty(t)
5337 e2termConn1.TestMsgChanEmpty(t)
5338 mainCtrl.wait_registry_empty(t, 10)
5341 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
5343 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5344 Counter{cRestSubReqFromXapp, 1},
5345 Counter{cRestSubRespToXapp, 1},
5346 Counter{cSubReqToE2, 2},
5347 Counter{cSubRespFromE2, 2},
5348 Counter{cRestSubNotifToXapp, 2},
5349 Counter{cRestSubDelReqFromXapp, 1},
5350 Counter{cSubDelReqToE2, 2},
5351 Counter{cSubDelRespFromE2, 2},
5352 Counter{cRestSubDelRespToXapp, 1},
5355 const subReqCount int = 2
5358 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5359 restSubId := xappConn1.SendRESTSubsReq(t, params)
5360 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5362 assert.Equal(t, len(e2SubsIds), 2)
5365 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5366 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5368 xappConn1.TestMsgChanEmpty(t)
5369 e2termConn1.TestMsgChanEmpty(t)
5370 mainCtrl.wait_registry_empty(t, 10)
5372 mainCtrl.VerifyCounterValues(t)
5374 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
5376 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5377 Counter{cRestSubReqFromXapp, 1},
5378 Counter{cRestSubRespToXapp, 1},
5379 Counter{cSubReqToE2, 19},
5380 Counter{cSubRespFromE2, 19},
5381 Counter{cRestSubNotifToXapp, 19},
5382 Counter{cRestSubDelReqFromXapp, 1},
5383 Counter{cSubDelReqToE2, 19},
5384 Counter{cSubDelRespFromE2, 19},
5385 Counter{cRestSubDelRespToXapp, 1},
5388 const subReqCount int = 19
5390 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5391 restSubId := xappConn1.SendRESTSubsReq(t, params)
5392 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5394 assert.Equal(t, len(e2SubsIds), 19)
5396 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5397 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5399 xappConn1.TestMsgChanEmpty(t)
5400 e2termConn1.TestMsgChanEmpty(t)
5401 mainCtrl.wait_registry_empty(t, 10)
5403 mainCtrl.VerifyCounterValues(t)
5406 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
5410 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5411 Counter{cRestSubReqFromXapp, 1},
5412 Counter{cRestSubRespToXapp, 1},
5413 Counter{cSubReqToE2, uint64(subReqCount)},
5414 Counter{cSubRespFromE2, uint64(subReqCount)},
5415 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5416 Counter{cRestSubDelReqFromXapp, 1},
5417 Counter{cSubDelReqToE2, uint64(subReqCount)},
5418 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5419 Counter{cRestSubDelRespToXapp, 1},
5423 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5424 restSubId := xappConn1.SendRESTSubsReq(t, params)
5425 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5427 assert.Equal(t, len(e2SubsIds), subReqCount)
5430 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5431 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5433 xappConn1.TestMsgChanEmpty(t)
5434 e2termConn1.TestMsgChanEmpty(t)
5435 mainCtrl.wait_registry_empty(t, 10)
5437 mainCtrl.VerifyCounterValues(t)
5440 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
5444 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5445 Counter{cRestSubReqFromXapp, 1},
5446 Counter{cRestSubRespToXapp, 1},
5447 Counter{cSubReqToE2, uint64(subReqCount)},
5448 Counter{cSubRespFromE2, uint64(subReqCount)},
5449 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5450 Counter{cRestSubDelReqFromXapp, 1},
5451 Counter{cSubDelReqToE2, uint64(subReqCount)},
5452 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5453 Counter{cRestSubDelRespToXapp, 1},
5457 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5458 restSubId := xappConn1.SendRESTSubsReq(t, params)
5459 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5461 assert.Equal(t, len(e2SubsIds), subReqCount)
5464 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5465 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5467 xappConn1.TestMsgChanEmpty(t)
5468 e2termConn1.TestMsgChanEmpty(t)
5469 mainCtrl.wait_registry_empty(t, 10)
5471 mainCtrl.VerifyCounterValues(t)
5474 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
5478 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5479 Counter{cRestSubReqFromXapp, 1},
5480 Counter{cRestSubRespToXapp, 1},
5481 Counter{cSubReqToE2, uint64(subReqCount)},
5482 Counter{cSubRespFromE2, uint64(subReqCount)},
5483 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5484 Counter{cRestSubDelReqFromXapp, 1},
5485 Counter{cSubDelReqToE2, uint64(subReqCount)},
5486 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5487 Counter{cRestSubDelRespToXapp, 1},
5491 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5492 restSubId := xappConn1.SendRESTSubsReq(t, params)
5493 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5495 assert.Equal(t, len(e2SubsIds), subReqCount)
5498 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5499 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5501 xappConn1.TestMsgChanEmpty(t)
5502 e2termConn1.TestMsgChanEmpty(t)
5503 mainCtrl.wait_registry_empty(t, 10)
5505 mainCtrl.VerifyCounterValues(t)
5508 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
5509 CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
5511 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5512 Counter{cRestSubReqFromXapp, 2},
5513 Counter{cRestSubRespToXapp, 2},
5514 Counter{cSubReqToE2, 2},
5515 Counter{cSubRespFromE2, 2},
5516 Counter{cRestSubNotifToXapp, 2},
5517 Counter{cRestSubDelReqFromXapp, 2},
5518 Counter{cSubDelReqToE2, 2},
5519 Counter{cSubDelRespFromE2, 2},
5520 Counter{cRestSubDelRespToXapp, 2},
5524 var params *teststube2ap.RESTSubsReqParams = nil
5527 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5528 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5530 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5533 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5534 params.SetMeid("RAN_NAME_1")
5535 eventTriggerDefinition := []int64{1234, 1}
5536 params.SetSubEventTriggerDefinition(eventTriggerDefinition)
5538 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5539 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5540 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5541 xappConn2.ExpectRESTNotification(t, restSubId2)
5542 e2termConn1.SendSubsResp(t, crereq, cremsg)
5543 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5545 deleteXapp1Subscription(t, &restSubId1)
5546 deleteXapp2Subscription(t, &restSubId2)
5548 waitSubsCleanup(t, e2SubsId1, 10)
5549 waitSubsCleanup(t, e2SubsId2, 10)
5551 mainCtrl.VerifyCounterValues(t)
5555 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
5556 CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
5558 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5559 Counter{cRestSubReqFromXapp, 2},
5560 Counter{cRestSubRespToXapp, 2},
5561 Counter{cSubReqToE2, 2},
5562 Counter{cSubRespFromE2, 2},
5563 Counter{cRestSubNotifToXapp, 2},
5564 Counter{cRestSubDelReqFromXapp, 2},
5565 Counter{cSubDelReqToE2, 2},
5566 Counter{cSubDelRespFromE2, 2},
5567 Counter{cRestSubDelRespToXapp, 2},
5571 var params *teststube2ap.RESTSubsReqParams = nil
5574 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5575 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5577 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5580 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5581 params.SetMeid("RAN_NAME_1")
5583 actionId := int64(1)
5584 actionType := "report"
5585 actionDefinition := []int64{5678, 1}
5586 subsequestActionType := "continue"
5587 timeToWait := "w10ms"
5588 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
5590 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5591 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5592 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5593 xappConn2.ExpectRESTNotification(t, restSubId2)
5594 e2termConn1.SendSubsResp(t, crereq, cremsg)
5595 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5597 deleteXapp1Subscription(t, &restSubId1)
5598 deleteXapp2Subscription(t, &restSubId2)
5600 waitSubsCleanup(t, e2SubsId1, 10)
5601 waitSubsCleanup(t, e2SubsId2, 10)
5603 mainCtrl.VerifyCounterValues(t)
5607 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
5608 CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
5610 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5611 Counter{cRestSubReqFromXapp, 2},
5612 Counter{cRestSubRespToXapp, 2},
5613 Counter{cSubReqToE2, 2},
5614 Counter{cSubRespFromE2, 2},
5615 Counter{cRestSubNotifToXapp, 2},
5616 Counter{cRestSubDelReqFromXapp, 2},
5617 Counter{cSubDelReqToE2, 2},
5618 Counter{cSubDelRespFromE2, 2},
5619 Counter{cRestSubDelRespToXapp, 2},
5623 var params *teststube2ap.RESTSubsReqParams = nil
5626 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5627 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5629 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5632 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5633 params.SetMeid("RAN_NAME_1")
5634 params.SetSubActionIDs(int64(2))
5636 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5637 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5638 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5639 xappConn2.ExpectRESTNotification(t, restSubId2)
5640 e2termConn1.SendSubsResp(t, crereq, cremsg)
5641 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5643 deleteXapp1Subscription(t, &restSubId1)
5644 deleteXapp2Subscription(t, &restSubId2)
5646 waitSubsCleanup(t, e2SubsId1, 10)
5647 waitSubsCleanup(t, e2SubsId2, 10)
5649 mainCtrl.VerifyCounterValues(t)
5653 func TestRESTSubReqDiffActionType(t *testing.T) {
5654 CaseBegin("TestRESTSubReqDiffActionType")
5656 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5657 Counter{cRestSubReqFromXapp, 2},
5658 Counter{cRestSubRespToXapp, 2},
5659 Counter{cSubReqToE2, 2},
5660 Counter{cSubRespFromE2, 2},
5661 Counter{cRestSubNotifToXapp, 2},
5662 Counter{cRestSubDelReqFromXapp, 2},
5663 Counter{cSubDelReqToE2, 2},
5664 Counter{cSubDelRespFromE2, 2},
5665 Counter{cRestSubDelRespToXapp, 2},
5668 const e2Timeout int64 = 2
5669 const e2RetryCount int64 = 2
5670 const routingNeeded bool = true
5673 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5674 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5677 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5678 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5680 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5683 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5684 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5685 params.SetMeid("RAN_NAME_1")
5687 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5688 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5689 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5690 xappConn2.ExpectRESTNotification(t, restSubId2)
5691 e2termConn1.SendSubsResp(t, crereq, cremsg)
5692 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5694 deleteXapp1Subscription(t, &restSubId1)
5695 deleteXapp2Subscription(t, &restSubId2)
5697 waitSubsCleanup(t, e2SubsId1, 10)
5698 waitSubsCleanup(t, e2SubsId2, 10)
5700 mainCtrl.VerifyCounterValues(t)
5704 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
5705 CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
5707 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5708 Counter{cRestSubReqFromXapp, 2},
5709 Counter{cRestSubRespToXapp, 2},
5710 Counter{cSubReqToE2, 2},
5711 Counter{cSubRespFromE2, 2},
5712 Counter{cRestSubNotifToXapp, 2},
5713 Counter{cRestSubDelReqFromXapp, 2},
5714 Counter{cSubDelReqToE2, 2},
5715 Counter{cSubDelRespFromE2, 2},
5716 Counter{cRestSubDelRespToXapp, 2},
5719 const e2Timeout int64 = 2
5720 const e2RetryCount int64 = 2
5721 const routingNeeded bool = true
5724 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5725 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5728 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5729 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5731 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5734 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
5735 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5736 params.SetMeid("RAN_NAME_1")
5738 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5739 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5740 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5741 xappConn2.ExpectRESTNotification(t, restSubId2)
5742 e2termConn1.SendSubsResp(t, crereq, cremsg)
5743 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5745 deleteXapp1Subscription(t, &restSubId1)
5746 deleteXapp2Subscription(t, &restSubId2)
5748 waitSubsCleanup(t, e2SubsId1, 10)
5749 waitSubsCleanup(t, e2SubsId2, 10)
5751 mainCtrl.VerifyCounterValues(t)
5755 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
5756 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
5758 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5759 Counter{cRestSubReqFromXapp, 2},
5760 Counter{cRestSubRespToXapp, 2},
5761 Counter{cSubReqToE2, 2},
5762 Counter{cSubRespFromE2, 2},
5763 Counter{cRestSubNotifToXapp, 2},
5764 Counter{cRestSubDelReqFromXapp, 2},
5765 Counter{cSubDelReqToE2, 2},
5766 Counter{cSubDelRespFromE2, 2},
5767 Counter{cRestSubDelRespToXapp, 2},
5771 var params *teststube2ap.RESTSubsReqParams = nil
5774 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5775 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5777 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5780 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5781 params.SetMeid("RAN_NAME_1")
5782 actionDefinition := []int64{5678, 1}
5783 params.SetSubActionDefinition(actionDefinition)
5785 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5786 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5787 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5788 xappConn2.ExpectRESTNotification(t, restSubId2)
5789 e2termConn1.SendSubsResp(t, crereq, cremsg)
5790 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5792 deleteXapp1Subscription(t, &restSubId1)
5793 deleteXapp2Subscription(t, &restSubId2)
5795 waitSubsCleanup(t, e2SubsId1, 10)
5796 waitSubsCleanup(t, e2SubsId2, 10)
5798 mainCtrl.VerifyCounterValues(t)
5802 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
5803 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
5805 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5806 Counter{cRestSubReqFromXapp, 2},
5807 Counter{cRestSubRespToXapp, 2},
5808 Counter{cSubReqToE2, 2},
5809 Counter{cSubRespFromE2, 2},
5810 Counter{cRestSubNotifToXapp, 2},
5811 Counter{cRestSubDelReqFromXapp, 2},
5812 Counter{cSubDelReqToE2, 2},
5813 Counter{cSubDelRespFromE2, 2},
5814 Counter{cRestSubDelRespToXapp, 2},
5818 var params *teststube2ap.RESTSubsReqParams = nil
5821 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5822 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5824 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5827 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5828 params.SetMeid("RAN_NAME_1")
5829 actionDefinition := []int64{56782}
5830 params.SetSubActionDefinition(actionDefinition)
5832 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5833 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5834 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5835 xappConn2.ExpectRESTNotification(t, restSubId2)
5836 e2termConn1.SendSubsResp(t, crereq, cremsg)
5837 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5839 deleteXapp1Subscription(t, &restSubId1)
5840 deleteXapp2Subscription(t, &restSubId2)
5842 waitSubsCleanup(t, e2SubsId1, 10)
5843 waitSubsCleanup(t, e2SubsId2, 10)
5845 mainCtrl.VerifyCounterValues(t)
5849 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
5850 CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
5852 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5853 Counter{cRestSubReqFromXapp, 2},
5854 Counter{cRestSubRespToXapp, 2},
5855 Counter{cSubReqToE2, 2},
5856 Counter{cSubRespFromE2, 2},
5857 Counter{cRestSubNotifToXapp, 2},
5858 Counter{cRestSubDelReqFromXapp, 2},
5859 Counter{cSubDelReqToE2, 2},
5860 Counter{cSubDelRespFromE2, 2},
5861 Counter{cRestSubDelRespToXapp, 2},
5865 var params *teststube2ap.RESTSubsReqParams = nil
5868 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5869 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5871 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5874 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5875 params.SetMeid("RAN_NAME_1")
5876 params.SetTimeToWait("w200ms")
5877 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5878 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5879 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5880 xappConn2.ExpectRESTNotification(t, restSubId2)
5881 e2termConn1.SendSubsResp(t, crereq, cremsg)
5882 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5884 deleteXapp1Subscription(t, &restSubId1)
5885 deleteXapp2Subscription(t, &restSubId2)
5887 waitSubsCleanup(t, e2SubsId1, 10)
5888 waitSubsCleanup(t, e2SubsId2, 10)
5890 mainCtrl.VerifyCounterValues(t)
5894 //-----------------------------------------------------------------------------
5895 // TestRESTUnpackSubscriptionResponseDecodeFail
5898 // +-------+ +---------+ +---------+
5899 // | xapp | | submgr | | e2term |
5900 // +-------+ +---------+ +---------+
5903 // |---------------->| |
5905 // | RESTSubResp | |
5906 // |<----------------| |
5909 // | |------------->|
5911 // | | SubResp | ASN.1 decode fails
5912 // | |<-------------|
5915 // | |------------->|
5917 // | | SubFail | Duplicated action
5918 // | |<-------------|
5919 // | RESTNotif (fail)| |
5920 // |<----------------| |
5923 //-----------------------------------------------------------------------------
5925 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
5926 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
5927 const subReqCount int = 1
5930 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5931 restSubId := xappConn1.SendRESTSubsReq(t, params)
5933 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5934 // Decode of this response fails which will result resending original request
5935 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
5937 _, cremsg = e2termConn1.RecvSubsReq(t)
5939 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
5941 // Subscription already created in E2 Node.
5942 fparams := &teststube2ap.E2StubSubsFailParams{}
5944 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5945 e2termConn1.SendSubsFail(t, fparams, cremsg)
5947 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5948 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5950 // Wait that subs is cleaned
5951 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5953 xappConn1.TestMsgChanEmpty(t)
5954 e2termConn1.TestMsgChanEmpty(t)
5955 mainCtrl.wait_registry_empty(t, 10)
5958 //-----------------------------------------------------------------------------
5959 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
5962 // +-------+ +---------+ +---------+
5963 // | xapp | | submgr | | e2term |
5964 // +-------+ +---------+ +---------+
5967 // |---------------->| |
5969 // | RESTSubResp | |
5970 // |<----------------| |
5973 // | |------------->|
5975 // | | SubResp | Unknown instanceId
5976 // | |<-------------|
5979 // | |------------->|
5981 // | | SubFail | Duplicated action
5982 // | |<-------------|
5983 // | RESTNotif (fail)| |
5984 // |<----------------| |
5986 // | |------------->|
5989 // | |<-------------|
5991 //-----------------------------------------------------------------------------
5993 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
5994 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
5995 const subReqCount int = 1
5998 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5999 restSubId := xappConn1.SendRESTSubsReq(t, params)
6001 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6003 // Unknown instanceId in this response which will result resending original request
6004 orgInstanceId := crereq.RequestId.InstanceId
6005 crereq.RequestId.InstanceId = 0
6006 e2termConn1.SendSubsResp(t, crereq, cremsg)
6008 _, cremsg = e2termConn1.RecvSubsReq(t)
6010 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6012 // Subscription already created in E2 Node.
6013 fparams := &teststube2ap.E2StubSubsFailParams{}
6015 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6016 e2termConn1.SendSubsFail(t, fparams, cremsg)
6018 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6019 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6021 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6022 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6024 // Wait that subs is cleaned
6025 mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
6027 xappConn1.TestMsgChanEmpty(t)
6028 e2termConn1.TestMsgChanEmpty(t)
6029 mainCtrl.wait_registry_empty(t, 10)
6032 //-----------------------------------------------------------------------------
6033 // TestRESTUnpackSubscriptionResponseNoTransaction
6036 // +-------+ +---------+ +---------+
6037 // | xapp | | submgr | | e2term |
6038 // +-------+ +---------+ +---------+
6041 // |---------------->| |
6043 // | RESTSubResp | |
6044 // |<----------------| |
6047 // | |------------->|
6049 // | | SubResp | No transaction for the response
6050 // | |<-------------|
6053 // | |------------->|
6055 // | | SubFail | Duplicated action
6056 // | |<-------------|
6057 // | RESTNotif (fail)| |
6058 // |<----------------| |
6060 // | |------------->|
6063 // | |<-------------|
6066 // | |------------->|
6069 // | |<-------------|
6071 //-----------------------------------------------------------------------------
6072 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
6073 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
6074 const subReqCount int = 1
6077 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6078 restSubId := xappConn1.SendRESTSubsReq(t, params)
6080 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6082 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6083 // No transaction exist for this response which will result resending original request
6084 e2termConn1.SendSubsResp(t, crereq, cremsg)
6086 _, cremsg = e2termConn1.RecvSubsReq(t)
6088 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6090 // Subscription already created in E2 Node.
6091 fparams := &teststube2ap.E2StubSubsFailParams{}
6093 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6094 e2termConn1.SendSubsFail(t, fparams, cremsg)
6096 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6097 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6099 // Resending happens because there no transaction
6100 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6101 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6103 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6104 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6106 // Wait that subs is cleaned
6107 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6109 xappConn1.TestMsgChanEmpty(t)
6110 e2termConn1.TestMsgChanEmpty(t)
6111 mainCtrl.wait_registry_empty(t, 10)
6115 //-----------------------------------------------------------------------------
6116 // TestRESTUnpackSubscriptionFailureDecodeFail
6119 // +-------+ +---------+ +---------+
6120 // | xapp | | submgr | | e2term |
6121 // +-------+ +---------+ +---------+
6124 // |---------------->| |
6126 // | RESTSubResp | |
6127 // |<----------------| |
6130 // | |------------->|
6132 // | | SubFail | ASN.1 decode fails
6133 // | |<-------------|
6136 // | |------------->|
6138 // | | SubFail | Duplicated action
6139 // | |<-------------|
6140 // | RESTNotif (fail)| |
6141 // |<----------------| |
6144 //-----------------------------------------------------------------------------
6145 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
6146 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
6147 const subReqCount int = 1
6150 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6151 restSubId := xappConn1.SendRESTSubsReq(t, params)
6153 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6155 // Decode of this response fails which will result resending original request
6156 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
6158 _, cremsg = e2termConn1.RecvSubsReq(t)
6160 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6162 // Subscription already created in E2 Node.
6163 fparams := &teststube2ap.E2StubSubsFailParams{}
6165 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6166 e2termConn1.SendSubsFail(t, fparams, cremsg)
6168 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6169 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6171 // Wait that subs is cleaned
6172 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6174 xappConn1.TestMsgChanEmpty(t)
6175 e2termConn1.TestMsgChanEmpty(t)
6176 mainCtrl.wait_registry_empty(t, 10)
6179 //-----------------------------------------------------------------------------
6180 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
6183 // +-------+ +---------+ +---------+
6184 // | xapp | | submgr | | e2term |
6185 // +-------+ +---------+ +---------+
6188 // |---------------->| |
6190 // | RESTSubResp | |
6191 // |<----------------| |
6194 // | |------------->|
6196 // | | SubFail | Unknown instanceId
6197 // | |<-------------|
6200 // | |------------->|
6202 // | | SubFail | Duplicated action
6203 // | |<-------------|
6204 // | RESTNotif (fail)| |
6205 // |<----------------| |
6207 // | |------------->|
6210 // | |<-------------|
6212 //-----------------------------------------------------------------------------
6213 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
6214 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
6215 const subReqCount int = 1
6218 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6219 restSubId := xappConn1.SendRESTSubsReq(t, params)
6221 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6223 // Unknown instanceId in this response which will result resending original request
6224 fparams := &teststube2ap.E2StubSubsFailParams{}
6226 fparams.Fail.RequestId.InstanceId = 0
6227 e2termConn1.SendSubsFail(t, fparams, cremsg)
6229 _, cremsg = e2termConn1.RecvSubsReq(t)
6231 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6233 // Subscription already created in E2 Node.
6234 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6235 e2termConn1.SendSubsFail(t, fparams, cremsg)
6237 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6238 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6240 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6241 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6243 // Wait that subs is cleaned
6244 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6246 xappConn1.TestMsgChanEmpty(t)
6247 e2termConn1.TestMsgChanEmpty(t)
6248 mainCtrl.wait_registry_empty(t, 10)
6251 //-----------------------------------------------------------------------------
6252 // TestRESTUnpackSubscriptionFailureNoTransaction
6255 // +-------+ +---------+ +---------+
6256 // | xapp | | submgr | | e2term |
6257 // +-------+ +---------+ +---------+
6260 // |---------------->| |
6262 // | RESTSubResp | |
6263 // |<----------------| |
6266 // | |------------->|
6268 // | | SubFail | No transaction for the response
6269 // | |<-------------|
6272 // | |------------->|
6274 // | | SubFail | Duplicated action
6275 // | |<-------------|
6276 // | RESTNotif (fail)| |
6277 // |<----------------| |
6279 // | |------------->|
6282 // | |<-------------|
6284 //-----------------------------------------------------------------------------
6285 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
6286 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
6287 const subReqCount int = 1
6290 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6291 restSubId := xappConn1.SendRESTSubsReq(t, params)
6293 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6295 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6297 // No transaction exist for this response which will result resending original request
6298 fparams := &teststube2ap.E2StubSubsFailParams{}
6300 e2termConn1.SendSubsFail(t, fparams, cremsg)
6302 _, cremsg = e2termConn1.RecvSubsReq(t)
6304 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6306 // Subscription already created in E2 Node.
6307 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6308 e2termConn1.SendSubsFail(t, fparams, cremsg)
6310 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6311 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6313 // Resending happens because there no transaction
6314 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6315 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6317 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6318 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6320 // Wait that subs is cleaned
6321 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6323 xappConn1.TestMsgChanEmpty(t)
6324 e2termConn1.TestMsgChanEmpty(t)
6325 mainCtrl.wait_registry_empty(t, 10)
6328 //-----------------------------------------------------------------------------
6329 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
6332 // +-------+ +---------+ +---------+
6333 // | xapp | | submgr | | e2term |
6334 // +-------+ +---------+ +---------+
6336 // | [SUBS CREATE] |
6339 // | RESTSubDelReq | |
6340 // |---------------->| |
6342 // | RESTSubDelResp | |
6343 // |<----------------| |
6346 // | |------------->|
6348 // | | SubDelResp | ASN.1 decode fails
6349 // | |<-------------|
6352 // | |------------->|
6354 // | | SubDelFail | Subscription does exist any more
6355 // | |<-------------|
6358 //-----------------------------------------------------------------------------
6359 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
6360 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail")
6363 var params *teststube2ap.RESTSubsReqParams = nil
6364 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6367 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6369 // E2t: Receive 1st SubsDelReq
6370 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6372 // Decode of this response fails which will result resending original request
6373 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_REQ)
6375 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6376 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6378 // Subscription does not exist in in E2 Node.
6379 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6381 // Wait that subs is cleaned
6382 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6384 xappConn1.TestMsgChanEmpty(t)
6385 e2termConn1.TestMsgChanEmpty(t)
6386 mainCtrl.wait_registry_empty(t, 10)
6389 //-----------------------------------------------------------------------------
6390 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
6393 // +-------+ +---------+ +---------+
6394 // | xapp | | submgr | | e2term |
6395 // +-------+ +---------+ +---------+
6397 // | [SUBS CREATE] |
6400 // | RESTSubDelReq | |
6401 // |---------------->| |
6403 // | RESTSubDelResp | |
6404 // |<----------------| |
6407 // | |------------->|
6409 // | | SubDelResp | Unknown instanceId
6410 // | |<-------------|
6413 // | |------------->|
6415 // | | SubDelFail | Subscription does exist any more
6416 // | |<-------------|
6418 //-----------------------------------------------------------------------------
6419 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
6420 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId")
6423 var params *teststube2ap.RESTSubsReqParams = nil
6424 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6427 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6429 // E2t: Receive 1st SubsDelReq
6430 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6432 // Unknown instanceId in this response which will result resending original request
6433 delreq.RequestId.InstanceId = 0
6434 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6436 // E2t: Receive 2nd SubsDelReq
6437 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6439 // Subscription does not exist in in E2 Node.
6440 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6442 // Wait that subs is cleaned
6443 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6445 xappConn1.TestMsgChanEmpty(t)
6446 e2termConn1.TestMsgChanEmpty(t)
6447 mainCtrl.wait_registry_empty(t, 10)
6450 //-----------------------------------------------------------------------------
6451 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
6454 // +-------+ +---------+ +---------+
6455 // | xapp | | submgr | | e2term |
6456 // +-------+ +---------+ +---------+
6458 // | [SUBS CREATE] |
6461 // | RESTSubDelReq | |
6462 // |---------------->| |
6464 // | RESTSubDelResp | |
6465 // |<----------------| |
6468 // | |------------->|
6470 // | | SubDelResp | No transaction for the response
6471 // | |<-------------|
6474 // | |------------->|
6476 // | | SubDelFail | Subscription does exist any more
6477 // | |<-------------|
6479 //-----------------------------------------------------------------------------
6480 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
6481 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction")
6484 var params *teststube2ap.RESTSubsReqParams = nil
6485 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6488 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6490 // E2t: Receive 1st SubsDelReq
6491 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6493 mainCtrl.MakeTransactionNil(t, e2SubsId)
6495 // No transaction exist for this response which will result resending original request
6496 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6498 // E2t: Receive 2nd SubsDelReq
6499 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6501 // Subscription does not exist in in E2 Node.
6502 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6504 // Wait that subs is cleaned
6505 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6507 xappConn1.TestMsgChanEmpty(t)
6508 e2termConn1.TestMsgChanEmpty(t)
6509 mainCtrl.wait_registry_empty(t, 10)
6512 //-----------------------------------------------------------------------------
6513 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
6516 // +-------+ +---------+ +---------+
6517 // | xapp | | submgr | | e2term |
6518 // +-------+ +---------+ +---------+
6520 // | [SUBS CREATE] |
6523 // | RESTSubDelReq | |
6524 // |---------------->| |
6526 // | RESTSubDelResp | |
6527 // |<----------------| |
6530 // | |------------->|
6532 // | | SubDelFail | ASN.1 decode fails
6533 // | |<-------------|
6536 // | |------------->|
6538 // | | SubDelFail | Subscription does exist any more
6539 // | |<-------------|
6541 //-----------------------------------------------------------------------------
6542 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
6543 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail")
6546 var params *teststube2ap.RESTSubsReqParams = nil
6547 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6550 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6552 // E2t: Receive 1st SubsDelReq
6553 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6555 // Decode of this response fails which will result resending original request
6556 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
6558 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6559 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6561 // Subscription does not exist in in E2 Node.
6562 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6564 // Wait that subs is cleaned
6565 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6567 xappConn1.TestMsgChanEmpty(t)
6568 e2termConn1.TestMsgChanEmpty(t)
6569 mainCtrl.wait_registry_empty(t, 10)
6572 //-----------------------------------------------------------------------------
6573 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
6576 // +-------+ +---------+ +---------+
6577 // | xapp | | submgr | | e2term |
6578 // +-------+ +---------+ +---------+
6580 // | [SUBS CREATE] |
6583 // | RESTSubDelReq | |
6584 // |---------------->| |
6586 // | RESTSubDelResp | |
6587 // |<----------------| |
6590 // | |------------->|
6592 // | | SubDelFail | Unknown instanceId
6593 // | |<-------------|
6596 // | |------------->|
6598 // | | SubDelFail | Subscription does exist any more
6599 // | |<-------------|
6601 //-----------------------------------------------------------------------------
6602 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
6603 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId")
6606 var params *teststube2ap.RESTSubsReqParams = nil
6607 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6610 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6612 // E2t: Receive 1st SubsDelReq
6613 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6615 // Unknown instanceId in this response which will result resending original request
6616 delreq.RequestId.InstanceId = 0
6617 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6619 // E2t: Receive 2nd SubsDelReq
6620 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6622 // Subscription does not exist in in E2 Node.
6623 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6625 // Wait that subs is cleaned
6626 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6628 xappConn1.TestMsgChanEmpty(t)
6629 e2termConn1.TestMsgChanEmpty(t)
6630 mainCtrl.wait_registry_empty(t, 10)
6633 //-----------------------------------------------------------------------------
6634 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
6637 // +-------+ +---------+ +---------+
6638 // | xapp | | submgr | | e2term |
6639 // +-------+ +---------+ +---------+
6641 // | [SUBS CREATE] |
6644 // | RESTSubDelReq | |
6645 // |---------------->| |
6647 // | RESTSubDelResp | |
6648 // |<----------------| |
6651 // | |------------->|
6653 // | | SubDelFail | No transaction for the response
6654 // | |<-------------|
6657 // | |------------->|
6659 // | | SubDelFail | Subscription does exist any more
6660 // | |<-------------|
6662 //-----------------------------------------------------------------------------
6663 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
6664 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction")
6667 var params *teststube2ap.RESTSubsReqParams = nil
6668 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6671 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6673 // E2t: Receive 1st SubsDelReq
6674 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6676 mainCtrl.MakeTransactionNil(t, e2SubsId)
6678 // No transaction exist for this response which will result resending original request
6679 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6681 // E2t: Receive 2nd SubsDelReq
6682 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6684 // Subscription does not exist in in E2 Node.
6685 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6687 // Wait that subs is cleaned
6688 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6690 xappConn1.TestMsgChanEmpty(t)
6691 e2termConn1.TestMsgChanEmpty(t)
6692 mainCtrl.wait_registry_empty(t, 10)
6695 //-----------------------------------------------------------------------------
6696 // TestRESTSubReqFailAsn1PackSubReqError
6699 // +-------+ +---------+ +---------+
6700 // | xapp | | submgr | | e2term |
6701 // +-------+ +---------+ +---------+
6704 // |---------------->| |
6706 // | RESTSubResp | |
6707 // |<----------------| |
6709 // | ASN.1 encode fails |
6712 // | |------------->|
6715 // | |<-------------|
6719 // |<----------------| |
6721 // | [SUBS DELETE] |
6724 //-----------------------------------------------------------------------------
6725 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
6727 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6728 Counter{cRestSubReqFromXapp, 1},
6729 Counter{cRestSubRespToXapp, 1},
6730 Counter{cRestSubFailNotifToXapp, 1},
6733 const subReqCount int = 1
6735 var params *teststube2ap.RESTSubsReqParams = nil
6736 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
6737 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
6740 restSubId := xappConn1.SendRESTSubsReq(t, params)
6741 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
6743 // E2t: Receive SubsDelReq
6744 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6746 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6747 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
6749 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
6750 // Wait that subs is cleaned
6751 waitSubsCleanup(t, e2SubsId, 10)
6752 mainCtrl.VerifyCounterValues(t)
6755 func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
6756 CaseBegin("TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction")
6758 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6759 Counter{cRestSubReqFromXapp, 2},
6760 Counter{cRestSubRespToXapp, 2},
6761 Counter{cSubReqToE2, 2},
6762 Counter{cSubRespFromE2, 1},
6763 Counter{cRestSubNotifToXapp, 1},
6764 Counter{cRestSubFailNotifToXapp, 1},
6765 Counter{cRestSubDelReqFromXapp, 1},
6766 Counter{cSubDelReqToE2, 1},
6767 Counter{cSubDelRespFromE2, 1},
6768 Counter{cRestSubDelRespToXapp, 1},
6771 const e2Timeout int64 = 1
6772 const e2RetryCount int64 = 0
6773 const routingNeeded bool = false
6776 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6777 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6780 restSubId := xappConn1.SendRESTSubsReq(t, params)
6781 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6783 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6784 xappConn1.ExpectRESTNotification(t, restSubId)
6785 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
6786 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6787 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
6790 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6791 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6792 params.SetSubscriptionID(&restSubId)
6793 params.SetTimeToWait("w200ms")
6794 restSubId = xappConn1.SendRESTSubsReq(t, params)
6795 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6797 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
6798 xappConn1.ExpectRESTNotification(t, restSubId)
6799 // SubsResp is missing, e2SubsId will be 0
6800 zeroE2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6801 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", zeroE2SubsId)
6804 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6805 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6806 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6808 waitSubsCleanup(t, e2SubsId, 10)
6810 mainCtrl.VerifyCounterValues(t)
6813 //-----------------------------------------------------------------------------
6814 // TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle
6817 // +-------+ +---------+ +---------+
6818 // | xapp | | submgr | | e2term |
6819 // +-------+ +---------+ +---------+
6822 // |---------------->| |
6824 // | RESTSubResp | |
6825 // |<----------------| |
6827 // | |------------->|
6830 // | |<-------------|
6833 // |<----------------| |
6836 // |---------------->| |
6838 // | RESTSubResp | |
6839 // |<----------------| |
6841 // | |------------->|
6843 // | Submgr restart |
6845 // | RESTSubDelReq | |
6846 // |---------------->| |
6849 // | |------------->|
6852 // | |<-------------|
6854 // | RESTSubDelResp | |
6855 // |<----------------| |
6857 //-----------------------------------------------------------------------------
6859 func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
6860 CaseBegin("TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle")
6862 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6863 Counter{cRestSubReqFromXapp, 2},
6864 Counter{cRestSubRespToXapp, 2},
6865 Counter{cSubReqToE2, 2},
6866 Counter{cSubRespFromE2, 1},
6867 Counter{cRestSubNotifToXapp, 1},
6868 Counter{cRestSubNotifToXapp, 1},
6869 Counter{cRestSubDelReqFromXapp, 1},
6870 Counter{cSubDelReqToE2, 1},
6871 Counter{cRestSubDelRespToXapp, 1},
6874 // Remove possible existing subscription
6875 mainCtrl.removeExistingSubscriptions(t)
6877 const e2Timeout int64 = 1
6878 const e2RetryCount int64 = 0
6879 const routingNeeded bool = false
6882 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6883 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6884 // Create subscription
6885 restSubId := xappConn1.SendRESTSubsReq(t, params)
6886 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6888 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6889 xappConn1.ExpectRESTNotification(t, restSubId)
6890 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
6891 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6892 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
6894 // Check subscription
6895 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
6898 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6899 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6900 params.SetSubscriptionID(&restSubId)
6901 params.SetTimeToWait("w200ms")
6902 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
6903 restSubId = xappConn1.SendRESTSubsReq(t, params)
6904 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6906 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
6907 mainCtrl.SetResetTestFlag(t, false)
6909 // SubsResp is missing due to submgr restart
6911 mainCtrl.SimulateRestart(t)
6912 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
6914 // Check subscription
6915 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
6917 xapp.Logger.Debug("Here 1")
6918 //<-time.After(3 * time.Second)
6919 xapp.Logger.Debug("Here 2")
6921 // Delete subscription
6922 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6923 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6924 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6926 //Wait that subs is cleaned
6927 waitSubsCleanup(t, e2SubsId, 10)
6929 mainCtrl.VerifyCounterValues(t)
6932 ////////////////////////////////////////////////////////////////////////////////////
6933 // Services for UT cases
6934 ////////////////////////////////////////////////////////////////////////////////////
6935 const subReqCount int = 1
6936 const host string = "localhost"
6938 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
6940 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
6942 restSubId := fromXappConn.SendRESTSubsReq(t, params)
6943 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
6945 crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
6946 fromXappConn.ExpectRESTNotification(t, restSubId)
6947 toE2termConn.SendSubsResp(t, crereq1, cremsg1)
6948 e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
6949 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
6951 return restSubId, e2SubsId
6954 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
6956 params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
6958 params.SetMeid(meid)
6960 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
6961 restSubId := xappConn2.SendRESTSubsReq(t, params)
6962 xappConn2.ExpectRESTNotification(t, restSubId)
6963 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
6964 e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
6965 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
6967 return restSubId, e2SubsId
6970 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
6972 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6973 restSubId := xappConn1.SendRESTSubsReq(t, params)
6974 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
6976 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6977 xappConn1.ExpectRESTNotification(t, restSubId)
6978 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
6979 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6980 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
6982 return restSubId, e2SubsId
6985 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
6986 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6987 restSubId := xappConn1.SendRESTSubsReq(t, params)
6989 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6990 fparams1 := &teststube2ap.E2StubSubsFailParams{}
6991 fparams1.Set(crereq1)
6992 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
6994 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
6995 xappConn1.ExpectRESTNotification(t, restSubId)
6996 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
6997 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6998 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
7000 return restSubId, e2SubsId
7003 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
7004 fromXappConn.SendRESTSubsDelReq(t, restSubId)
7005 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
7006 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
7009 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
7010 xappConn1.SendRESTSubsDelReq(t, restSubId)
7011 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7012 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7015 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
7016 xappConn2.SendRESTSubsDelReq(t, restSubId)
7017 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7018 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7021 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
7022 resp, _ := xapp.Subscription.QuerySubscriptions()
7023 assert.Equal(t, resp[0].SubscriptionID, e2SubsId)
7024 assert.Equal(t, resp[0].Meid, meid)
7025 assert.Equal(t, resp[0].ClientEndpoint, endpoint)
7028 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
7029 //Wait that subs is cleaned
7030 mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
7032 xappConn1.TestMsgChanEmpty(t)
7033 xappConn2.TestMsgChanEmpty(t)
7034 e2termConn1.TestMsgChanEmpty(t)
7035 mainCtrl.wait_registry_empty(t, timeout)
7038 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
7040 var e2SubsId []uint32
7042 for i := 0; i < count; i++ {
7043 xapp.Logger.Debug("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
7044 crereq, cremsg := toE2termConn.RecvSubsReq(t)
7045 fromXappConn.ExpectRESTNotification(t, restSubId)
7046 toE2termConn.SendSubsResp(t, crereq, cremsg)
7047 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
7048 e2SubsId = append(e2SubsId, instanceId)
7049 xapp.Logger.Debug("TEST: %v", e2SubsId)
7050 xapp.Logger.Debug("TEST: %d ===================================== END CRE ============================================", i+1)
7051 <-time.After(100 * time.Millisecond)
7056 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
7058 for i := 0; i < len(e2SubsIds); i++ {
7059 xapp.Logger.Debug("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
7060 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
7061 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
7062 <-time.After(1 * time.Second)
7063 xapp.Logger.Debug("TEST: %d ===================================== END DEL ============================================", i+1)
7064 <-time.After(100 * time.Millisecond)
7067 // Wait that subs is cleaned
7068 for i := 0; i < len(e2SubsIds); i++ {
7069 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)