2 ==================================================================================
3 Copyright (c) 2019 AT&T Intellectual Property.
4 Copyright (c) 2019 Nokia
6 Licensed under the Apache License, Version 2.0 (the "License");
7 you may not use this file except in compliance with the License.
8 You may obtain a copy of the License at
10 http://www.apache.org/licenses/LICENSE-2.0
12 Unless required by applicable law or agreed to in writing, software
13 distributed under the License is distributed on an "AS IS" BASIS,
14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 See the License for the specific language governing permissions and
16 limitations under the License.
17 ==================================================================================
27 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
28 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper"
29 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
30 "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststube2ap"
31 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
32 "github.com/stretchr/testify/assert"
35 // In below test cases there is done only one retry for E2 messages
36 // In Helm chart retry count is currently 2 By default. Retry count
37 // used in test cases is defined in submgr-config.yaml file.
39 func TestSuiteSetup(t *testing.T) {
40 // The effect of this call shall endure though the UT suite!
41 // If this causes any issues, the previous interface can be restored
43 // SetPackerIf(e2ap_wrapper.NewAsn1E2APPacker())
45 mainCtrl.InitAllCounterMap()
46 SetPackerIf(e2ap_wrapper.NewUtAsn1E2APPacker())
47 mainCtrl.c.restDuplicateCtrl.Init()
50 func TestRanStatusChangeViaSDLNotification(t *testing.T) {
52 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
53 Counter{cE2StateChangedToUp, 3},
56 // Current UT test cases use these ran names
57 xappRnibMock.CreateGnb("RAN_NAME_1", entities.ConnectionStatus_DISCONNECTED)
58 xappRnibMock.CreateGnb("RAN_NAME_11", entities.ConnectionStatus_DISCONNECTED)
59 xappRnibMock.CreateGnb("RAN_NAME_2", entities.ConnectionStatus_DISCONNECTED)
61 mainCtrl.c.e2IfState.ReadE2ConfigurationFromRnib()
62 mainCtrl.c.e2IfState.SubscribeChannels()
64 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
65 mainCtrl.SetE2State(t, "RAN_NAME_2_CONNECTED")
66 mainCtrl.SetE2State(t, "RAN_NAME_11_CONNECTED")
68 mainCtrl.VerifyCounterValues(t)
71 //-----------------------------------------------------------------------------
72 // TestRESTSubReqAfterE2ConnBreak
75 // +-------+ +---------+ +---------+
76 // | xapp | | submgr | | e2term |
77 // +-------+ +---------+ +---------+
79 // | [E2 Conn. DOWN] |
82 // |---------------->| |
84 // |<----------------| |
87 //-----------------------------------------------------------------------------
89 func TestRESTSubReqAfterE2ConnBreak(t *testing.T) {
91 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
92 Counter{cRestSubReqFromXapp, 1},
93 Counter{cRestReqRejDueE2Down, 1},
94 Counter{cE2StateChangedToDown, 1},
95 Counter{cE2StateChangedToUp, 1},
98 // E2 disconnect after E2term has received response
99 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
101 const subReqCount int = 1
102 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
103 xappConn1.SendRESTSubsReq(t, params)
105 // Restore E2 connection for following test cases
106 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
108 mainCtrl.VerifyAllClean(t)
109 mainCtrl.VerifyCounterValues(t)
112 //-----------------------------------------------------------------------------
113 // TestRESTSubReqE2ConnBreak
116 // +-------+ +---------+ +---------+
117 // | xapp | | submgr | | e2term |
118 // +-------+ +---------+ +---------+
121 // |---------------->| |
123 // |<----------------| |
125 // | |------------->|
127 // | |<-------------|
129 // | [E2 Conn. DOWN] |
130 // | [Int. SUBS DELETE] |
132 // | RESTNotif(unsuccessful) |
133 // |<----------------| |
137 //-----------------------------------------------------------------------------
138 func TestRESTSubReqE2ConnBreak(t *testing.T) {
140 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
141 Counter{cRestSubReqFromXapp, 1},
142 Counter{cRestSubRespToXapp, 1},
143 Counter{cSubReqToE2, 1},
144 Counter{cSubRespFromE2, 1},
145 Counter{cRestSubFailNotifToXapp, 1},
146 Counter{cE2StateChangedToDown, 1},
147 Counter{cE2StateChangedToUp, 1},
151 const subReqCount int = 1
152 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
153 restSubId := xappConn1.SendRESTSubsReq(t, params)
155 crereq, cremsg := e2termConn1.RecvSubsReq(t)
156 xappConn1.ExpectRESTNotification(t, restSubId)
158 // E2 disconnect after E2term has received response
159 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
161 e2termConn1.SendSubsResp(t, crereq, cremsg)
162 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
164 <-time.After(time.Second * 1)
165 assert.Equal(t, 0, len(mainCtrl.c.registry.register))
166 assert.Equal(t, 0, len(mainCtrl.c.registry.restSubscriptions))
168 subIds, register, err := mainCtrl.c.ReadAllSubscriptionsFromSdl()
170 xapp.Logger.Error("%v", err)
172 assert.Equal(t, 65534, len(subIds)) // range 1-65535 , FFFF = 65535
173 assert.Equal(t, 0, len(register))
176 restSubscriptions, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
178 xapp.Logger.Error("%v", err)
180 assert.Equal(t, 0, len(restSubscriptions))
183 // Restore E2 connection for following test cases
184 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
186 // Wait that subs is cleaned
187 waitSubsCleanup(t, e2SubsId, 10)
188 mainCtrl.VerifyCounterValues(t)
189 mainCtrl.VerifyAllClean(t)
192 //-----------------------------------------------------------------------------
193 // TestRESTSubscriptionDeleteAfterE2ConnectionBreak
196 // +-------+ +---------+ +---------+
197 // | xapp | | submgr | | e2term |
198 // +-------+ +---------+ +---------+
202 // | [E2 Conn. DOWN] |
204 // | RESTSubDelReq | |
205 // |---------------->| |
207 // | RESTSubDelResp | |
208 // |<----------------| |
210 // | [No valid subscription found] |
213 //-----------------------------------------------------------------------------
214 func TestRESTSubscriptionDeleteAfterE2ConnectionBreak(t *testing.T) {
215 xapp.Logger.Debug("TEST: TestRESTSubscriptionDeleteAfterE2ConnectionBreak")
217 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
218 Counter{cRestSubReqFromXapp, 1},
219 Counter{cRestSubRespToXapp, 1},
220 Counter{cSubReqToE2, 1},
221 Counter{cSubRespFromE2, 1},
222 Counter{cRestSubNotifToXapp, 1},
223 Counter{cRestSubDelReqFromXapp, 1},
224 Counter{cRestSubDelRespToXapp, 1},
225 Counter{cE2StateChangedToDown, 1},
226 Counter{cE2StateChangedToUp, 1},
230 var params *teststube2ap.RESTSubsReqParams = nil
231 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
233 // E2 disconnect after E2term has received response
234 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
237 xappConn1.SendRESTSubsDelReq(t, &restSubId)
239 <-time.After(time.Second * 1)
240 assert.Equal(t, 0, len(mainCtrl.c.registry.register))
241 assert.Equal(t, 0, len(mainCtrl.c.registry.restSubscriptions))
243 subIds, register, err := mainCtrl.c.ReadAllSubscriptionsFromSdl()
245 xapp.Logger.Error("%v", err)
247 assert.Equal(t, 65534, len(subIds)) // range 1-65535 , FFFF = 65535
248 assert.Equal(t, 0, len(register))
251 restSubscriptions, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
253 xapp.Logger.Error("%v", err)
255 assert.Equal(t, 0, len(restSubscriptions))
258 // Restore E2 connection for following test cases
259 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
261 // Wait that subs is cleaned
262 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
264 xappConn1.TestMsgChanEmpty(t)
265 e2termConn1.TestMsgChanEmpty(t)
266 mainCtrl.wait_registry_empty(t, 10)
267 mainCtrl.VerifyCounterValues(t)
268 mainCtrl.VerifyAllClean(t)
271 //-----------------------------------------------------------------------------
272 // TestRESTOtherE2ConnectionChanges
276 // +-------+ +---------+ +---------+
277 // | xapp | | submgr | | e2term |
278 // +-------+ +---------+ +---------+
282 // | [E2 CONNECTED_SETUP_FAILED] |
283 // | [E2 CONNECTING] |
284 // | [E2 SHUTTING_DOWN] |
285 // | [E2 SHUT_DOWN] |
290 //-----------------------------------------------------------------------------
291 func TestRESTOtherE2ConnectionChanges(t *testing.T) {
292 xapp.Logger.Debug("TEST: TestRESTOtherE2ConnectionChanges")
294 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
295 Counter{cRestSubReqFromXapp, 1},
296 Counter{cRestSubRespToXapp, 1},
297 Counter{cSubReqToE2, 1},
298 Counter{cSubRespFromE2, 1},
299 Counter{cRestSubNotifToXapp, 1},
300 Counter{cRestSubDelReqFromXapp, 1},
301 Counter{cSubDelReqToE2, 1},
302 Counter{cSubDelRespFromE2, 1},
303 Counter{cRestSubDelRespToXapp, 1},
304 Counter{cE2StateChangedToUp, 1},
308 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
309 restSubId := xappConn1.SendRESTSubsReq(t, params)
311 crereq, cremsg := e2termConn1.RecvSubsReq(t)
312 xappConn1.ExpectRESTNotification(t, restSubId)
313 e2termConn1.SendSubsResp(t, crereq, cremsg)
314 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
316 // Submgr should not react to any other connection state changes than CONNECTED and DISCONNECTED
317 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED_SETUP_FAILED")
318 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTING")
319 mainCtrl.SetE2State(t, "RAN_NAME_1_SHUTTING_DOWN")
320 mainCtrl.SetE2State(t, "RAN_NAME_1_SHUT_DOWN")
323 xappConn1.SendRESTSubsDelReq(t, &restSubId)
324 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
325 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
327 // Restore E2 connection for following test cases
328 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
330 // Wait that subs is cleaned
331 waitSubsCleanup(t, e2SubsId, 10)
332 mainCtrl.VerifyCounterValues(t)
333 mainCtrl.VerifyAllClean(t)
336 //-----------------------------------------------------------------------------
337 // TestRESTSubReqAndDeleteOkWithE2apUtWrapper
340 // +-------+ +---------+ +---------+ +---------+
341 // | xapp | | submgr | | e2term | | rtmgr |
342 // +-------+ +---------+ +---------+ +---------+
344 // | RESTSubReq | | |
345 // |---------------->| | |
346 // | | RouteCreate | |
347 // | |--------------------------->| // The order of these events may vary
349 // | RESTSubResp | | | // The order of these events may vary
350 // |<----------------| | |
351 // | | RouteResponse| |
352 // | |<---------------------------| // The order of these events may vary
355 // | |------------->| | // The order of these events may vary
358 // | |<-------------| |
359 // | RESTNotif1 | | |
360 // |<----------------| | |
362 // | RESTSubDelReq | | |
363 // |---------------->| | |
365 // | |------------->| |
367 // | RESTSubDelResp| | |
368 // |<----------------| | |
370 // | | SubDelResp | |
371 // | |<-------------| |
375 //-----------------------------------------------------------------------------
376 func TestRESTSubReqAndDeleteOkWithE2apUtWrapper(t *testing.T) {
378 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
380 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
382 waitSubsCleanup(t, e2SubsId, 10)
383 mainCtrl.VerifyAllClean(t)
386 //-----------------------------------------------------------------------------
387 // TestRESTSubReqAndE1apDeleteReqPackingError
390 // +-------+ +---------+ +---------+ +---------+
391 // | xapp | | submgr | | e2term | | rtmgr |
392 // +-------+ +---------+ +---------+ +---------+
394 // | RESTSubReq | | |
395 // |---------------->| | |
396 // | | RouteCreate | |
397 // | |--------------------------->| // The order of these events may vary
399 // | RESTSubResp | | | // The order of these events may vary
400 // |<----------------| | |
401 // | | RouteResponse| |
402 // | |<---------------------------| // The order of these events may vary
405 // | |------------->| | // The order of these events may vary
408 // | |<-------------| |
409 // | RESTNotif1 | | |
410 // |<----------------| | |
412 // | RESTSubDelReq | | |
413 // |---------------->| | |
415 // | RESTSubDelResp| | |
416 // |<----------------| | |
420 //-----------------------------------------------------------------------------
421 func TestRESTSubReqAndE1apDeleteReqPackingError(t *testing.T) {
423 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
425 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, false)
426 xappConn1.SendRESTSubsDelReq(t, &restSubId)
427 defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, true)
429 waitSubsCleanup(t, e2SubsId, 10)
430 mainCtrl.VerifyAllClean(t)
433 //-----------------------------------------------------------------------------
434 // TestRESTSubReqAndE1apDeleteRespUnpackingError
437 // +-------+ +---------+ +---------+ +---------+
438 // | xapp | | submgr | | e2term | | rtmgr |
439 // +-------+ +---------+ +---------+ +---------+
441 // | RESTSubReq | | |
442 // |---------------->| | |
443 // | | RouteCreate | |
444 // | |--------------------------->| // The order of these events may vary
446 // | RESTSubResp | | | // The order of these events may vary
447 // |<----------------| | |
448 // | | RouteResponse| |
449 // | |<---------------------------| // The order of these events may vary
452 // | |------------->| | // The order of these events may vary
455 // | |<-------------| |
456 // | RESTNotif1 | | |
457 // |<----------------| | |
459 // | RESTSubDelReq | | |
460 // |---------------->| | |
462 // | |------------->| |
464 // | RESTSubDelResp| | |
465 // |<----------------| | | // The order of these events may vary
467 // | | SubDelResp | |
468 // | |<-------------| | // 1.st NOK
471 // | |------------->| |
473 // | | SubDelResp | |
474 // | |<-------------| | // 2.nd NOK
476 //-----------------------------------------------------------------------------
478 func TestRESTSubReqAndE1apDeleteRespUnpackingError(t *testing.T) {
480 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
482 xappConn1.SendRESTSubsDelReq(t, &restSubId)
483 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, false)
484 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
485 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
487 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
488 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
490 defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, true)
492 waitSubsCleanup(t, e2SubsId, 10)
493 mainCtrl.VerifyAllClean(t)
496 //-----------------------------------------------------------------------------
497 // TestSubReqAndRouteNok
500 // +-------+ +---------+ +---------+
501 // | xapp | | submgr | | rtmgr |
502 // +-------+ +---------+ +---------+
505 // |------------->| |
508 // | |------------->|
512 // | |<-------------|
514 // | [SUBS INT DELETE] |
517 //-----------------------------------------------------------------------------
519 func TestSubReqAndRouteNok(t *testing.T) {
520 CaseBegin("TestSubReqAndRouteNok")
522 // Init counter check
523 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
524 Counter{cSubReqFromXapp, 1},
525 Counter{cRouteCreateFail, 1},
528 waiter := rtmgrHttp.AllocNextEvent(false)
529 newSubsId := mainCtrl.get_registry_next_subid(t)
530 xappConn1.SendSubsReq(t, nil, nil)
533 //Wait that subs is cleaned
534 mainCtrl.wait_subs_clean(t, newSubsId, 10)
536 xappConn1.TestMsgChanEmpty(t)
537 xappConn2.TestMsgChanEmpty(t)
538 e2termConn1.TestMsgChanEmpty(t)
539 mainCtrl.wait_registry_empty(t, 10)
541 <-time.After(1 * time.Second)
542 mainCtrl.VerifyCounterValues(t)
545 //-----------------------------------------------------------------------------
546 // TestSubReqAndRouteUpdateNok
549 // +-------+ +-------+ +---------+ +---------+
550 // | xapp2 | | xapp1 | | submgr | | rtmgr |
551 // +-------+ +-------+ +---------+ +---------+
553 // | [SUBS CREATE] | |
557 // | SubReq (mergeable) | |
558 // |--------------------------->| | |
560 // | | | RouteUpdate |
561 // | | |------------->|
563 // | | | RouteUpdate |
564 // | | | status:400 |
565 // | | |<-------------|
567 // | [SUBS INT DELETE] | |
570 // | [SUBS DELETE] | |
573 func TestSubReqAndRouteUpdateNok(t *testing.T) {
574 CaseBegin("TestSubReqAndRouteUpdateNok")
576 // Init counter check
577 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
578 Counter{cSubReqFromXapp, 2},
579 Counter{cSubReqToE2, 1},
580 Counter{cSubRespFromE2, 1},
581 Counter{cSubRespToXapp, 1},
582 Counter{cRouteCreateUpdateFail, 1},
583 Counter{cSubDelReqFromXapp, 1},
584 Counter{cSubDelReqToE2, 1},
585 Counter{cSubDelRespFromE2, 1},
586 Counter{cSubDelRespToXapp, 1},
589 cretrans := xappConn1.SendSubsReq(t, nil, nil)
590 crereq, cremsg := e2termConn1.RecvSubsReq(t)
591 e2termConn1.SendSubsResp(t, crereq, cremsg)
592 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
594 resp, _ := xapp.Subscription.QuerySubscriptions()
595 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
596 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
597 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
599 waiter := rtmgrHttp.AllocNextEvent(false)
600 newSubsId := mainCtrl.get_registry_next_subid(t)
601 xappConn2.SendSubsReq(t, nil, nil)
604 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
605 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
607 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
608 xappConn1.RecvSubsDelResp(t, deltrans)
610 //Wait that subs is cleaned
611 mainCtrl.wait_subs_clean(t, newSubsId, 10)
612 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
614 xappConn1.TestMsgChanEmpty(t)
615 xappConn2.TestMsgChanEmpty(t)
616 e2termConn1.TestMsgChanEmpty(t)
617 mainCtrl.wait_registry_empty(t, 10)
619 mainCtrl.VerifyCounterValues(t)
622 //-----------------------------------------------------------------------------
623 // TestSubDelReqAndRouteDeleteNok
626 // +-------+ +---------+ +---------+ +---------+
627 // | xapp | | submgr | | e2term | | rtmgr |
628 // +-------+ +---------+ +---------+ +---------+
630 // | [SUBS CREATE] | |
635 // |------------->| | |
637 // | |------------->| |
639 // | |<-------------| |
641 // |<-------------| | |
642 // | | RouteDelete | |
643 // | |---------------------------->|
645 // | | RouteDelete | |
646 // | | status:400 | |
647 // | |<----------------------------|
649 func TestSubDelReqAndRouteDeleteNok(t *testing.T) {
650 CaseBegin("TestSubDelReqAndRouteDeleteNok")
652 // Init counter check
653 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
654 Counter{cSubReqFromXapp, 1},
655 Counter{cSubReqToE2, 1},
656 Counter{cSubRespFromE2, 1},
657 Counter{cSubRespToXapp, 1},
658 Counter{cSubDelReqFromXapp, 1},
659 Counter{cRouteDeleteFail, 1},
660 Counter{cSubDelReqToE2, 1},
661 Counter{cSubDelRespFromE2, 1},
662 Counter{cSubDelRespToXapp, 1},
665 cretrans := xappConn1.SendSubsReq(t, nil, nil)
666 crereq, cremsg := e2termConn1.RecvSubsReq(t)
667 e2termConn1.SendSubsResp(t, crereq, cremsg)
668 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
670 resp, _ := xapp.Subscription.QuerySubscriptions()
671 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
672 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
673 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
675 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
676 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
678 waiter := rtmgrHttp.AllocNextEvent(false)
679 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
682 xappConn1.RecvSubsDelResp(t, deltrans)
684 //Wait that subs is cleaned
685 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
687 xappConn1.TestMsgChanEmpty(t)
688 xappConn2.TestMsgChanEmpty(t)
689 e2termConn1.TestMsgChanEmpty(t)
690 mainCtrl.wait_registry_empty(t, 10)
691 mainCtrl.VerifyCounterValues(t)
694 //-----------------------------------------------------------------------------
695 // TestSubMergeDelAndRouteUpdateNok
697 // +-------+ +-------+ +---------+ +---------+
698 // | xapp2 | | xapp1 | | submgr | | e2term |
699 // +-------+ +-------+ +---------+ +---------+
704 // | |------------->| |
707 // | | |------------->|
709 // | | |<-------------|
711 // | |<-------------| |
714 // |--------------------------->| |
717 // |<---------------------------| |
719 // | | SubDelReq 1 | |
720 // | |------------->| |
721 // | | | RouteUpdate |
722 // | | |-----> rtmgr |
724 // | | | RouteUpdate |
725 // | | | status:400 |
726 // | | |<----- rtmgr |
728 // | | SubDelResp 1 | |
729 // | |<-------------| |
732 // |--------------------------->| |
734 // | | | SubDelReq 2 |
735 // | | |------------->|
737 // | | | SubDelReq 2 |
738 // | | |------------->|
740 // | SubDelResp 2 | |
741 // |<---------------------------| |
743 //-----------------------------------------------------------------------------
744 func TestSubMergeDelAndRouteUpdateNok(t *testing.T) {
745 CaseBegin("TestSubMergeDelAndRouteUpdateNok")
747 // Init counter check
748 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
749 Counter{cSubReqFromXapp, 2},
750 Counter{cMergedSubscriptions, 1},
751 Counter{cSubReqToE2, 1},
752 Counter{cSubRespFromE2, 1},
753 Counter{cSubRespToXapp, 2},
754 Counter{cSubDelReqFromXapp, 2},
755 Counter{cRouteDeleteUpdateFail, 1},
756 Counter{cSubDelReqToE2, 1},
757 Counter{cSubDelRespFromE2, 1},
758 Counter{cSubDelRespToXapp, 2},
759 Counter{cUnmergedSubscriptions, 1},
763 rparams1 := &teststube2ap.E2StubSubsReqParams{}
765 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
766 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
767 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
768 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
771 rparams2 := &teststube2ap.E2StubSubsReqParams{}
773 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
774 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
776 resp, _ := xapp.Subscription.QuerySubscriptions()
777 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
778 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
779 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
782 waiter := rtmgrHttp.AllocNextEvent(false)
783 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
786 xappConn1.RecvSubsDelResp(t, deltrans1)
789 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
790 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
791 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
792 xappConn2.RecvSubsDelResp(t, deltrans2)
793 //Wait that subs is cleaned
794 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
796 xappConn1.TestMsgChanEmpty(t)
797 xappConn2.TestMsgChanEmpty(t)
798 e2termConn1.TestMsgChanEmpty(t)
799 mainCtrl.wait_registry_empty(t, 10)
801 mainCtrl.VerifyCounterValues(t)
804 //-----------------------------------------------------------------------------
806 //-----------------------------------------------------------------------------
807 // TestSubReqAndSubDelOk
810 // +-------+ +---------+ +---------+
811 // | xapp | | submgr | | e2term |
812 // +-------+ +---------+ +---------+
815 // |------------->| |
818 // | |------------->|
821 // | |<-------------|
824 // |<-------------| |
828 // |------------->| |
831 // | |------------->|
834 // | |<-------------|
837 // |<-------------| |
839 //-----------------------------------------------------------------------------
840 func TestSubReqAndSubDelOk(t *testing.T) {
841 CaseBegin("TestSubReqAndSubDelOk")
843 // Init counter check
844 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
845 Counter{cSubReqFromXapp, 1},
846 Counter{cSubReqToE2, 1},
847 Counter{cSubRespFromE2, 1},
848 Counter{cSubRespToXapp, 1},
849 Counter{cSubDelReqFromXapp, 1},
850 Counter{cSubDelReqToE2, 1},
851 Counter{cSubDelRespFromE2, 1},
852 Counter{cSubDelRespToXapp, 1},
855 cretrans := xappConn1.SendSubsReq(t, nil, nil)
856 crereq, cremsg := e2termConn1.RecvSubsReq(t)
857 e2termConn1.SendSubsResp(t, crereq, cremsg)
858 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
860 resp, _ := xapp.Subscription.QuerySubscriptions()
861 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
862 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
863 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
865 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
866 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
868 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
869 xappConn1.RecvSubsDelResp(t, deltrans)
871 //Wait that subs is cleaned
872 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
874 xappConn1.TestMsgChanEmpty(t)
875 xappConn2.TestMsgChanEmpty(t)
876 e2termConn1.TestMsgChanEmpty(t)
877 mainCtrl.wait_registry_empty(t, 10)
879 mainCtrl.VerifyCounterValues(t)
882 //-----------------------------------------------------------------------------
883 // TestSubReqRetransmission
886 // +-------+ +---------+ +---------+
887 // | xapp | | submgr | | e2term |
888 // +-------+ +---------+ +---------+
891 // |------------->| |
894 // | |------------->|
898 // |------------->| |
901 // | |<-------------|
904 // |<-------------| |
909 //-----------------------------------------------------------------------------
910 func TestSubReqRetransmission(t *testing.T) {
911 CaseBegin("TestSubReqRetransmission")
914 cretrans := xappConn1.SendSubsReq(t, nil, nil)
915 crereq, cremsg := e2termConn1.RecvSubsReq(t)
917 seqBef := mainCtrl.get_msgcounter(t)
918 xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq
919 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
921 // hack as there is no real way to see has message be handled.
922 // Previuos counter check just tells that is has been received by submgr
923 // --> artificial delay
924 <-time.After(1 * time.Second)
925 e2termConn1.SendSubsResp(t, crereq, cremsg)
926 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
929 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
930 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
931 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
932 xappConn1.RecvSubsDelResp(t, deltrans)
934 //Wait that subs is cleaned
935 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
937 xappConn1.TestMsgChanEmpty(t)
938 xappConn2.TestMsgChanEmpty(t)
939 e2termConn1.TestMsgChanEmpty(t)
940 mainCtrl.wait_registry_empty(t, 10)
943 //-----------------------------------------------------------------------------
944 // TestSubDelReqRetransmission
947 // +-------+ +---------+ +---------+
948 // | xapp | | submgr | | e2term |
949 // +-------+ +---------+ +---------+
955 // |------------->| |
958 // | |------------->|
963 // |------------->| |
966 // | |<-------------|
969 // |<-------------| |
971 //-----------------------------------------------------------------------------
972 func TestSubDelReqRetransmission(t *testing.T) {
973 CaseBegin("TestSubDelReqRetransmission")
976 cretrans := xappConn1.SendSubsReq(t, nil, nil)
977 crereq, cremsg := e2termConn1.RecvSubsReq(t)
978 e2termConn1.SendSubsResp(t, crereq, cremsg)
979 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
982 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
983 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
985 seqBef := mainCtrl.get_msgcounter(t)
986 xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq
987 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
989 // hack as there is no real way to see has message be handled.
990 // Previuos counter check just tells that is has been received by submgr
991 // --> artificial delay
992 <-time.After(1 * time.Second)
994 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
995 xappConn1.RecvSubsDelResp(t, deltrans)
997 //Wait that subs is cleaned
998 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1000 xappConn1.TestMsgChanEmpty(t)
1001 xappConn2.TestMsgChanEmpty(t)
1002 e2termConn1.TestMsgChanEmpty(t)
1003 mainCtrl.wait_registry_empty(t, 10)
1006 //-----------------------------------------------------------------------------
1007 // TestSubDelReqCollision
1010 // +-------+ +---------+ +---------+
1011 // | xapp | | submgr | | e2term |
1012 // +-------+ +---------+ +---------+
1014 // | [SUBS CREATE] |
1017 // | SubDelReq 1 | |
1018 // |------------->| |
1020 // | | SubDelReq 1 |
1021 // | |------------->|
1023 // | SubDelReq 2 | |
1026 // |------------->| |
1028 // | | SubDelResp 1 |
1029 // | |<-------------|
1031 // | SubDelResp 1 | |
1032 // |<-------------| |
1034 // | SubDelResp 2 | |
1035 // |<-------------| |
1037 //-----------------------------------------------------------------------------
1039 func TestSubDelReqCollision(t *testing.T) {
1040 CaseBegin("TestSubDelReqCollision")
1043 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1044 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1045 e2termConn1.SendSubsResp(t, crereq, cremsg)
1046 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1049 xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1050 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1052 // Subs Delete colliding
1053 seqBef := mainCtrl.get_msgcounter(t)
1054 deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1055 xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq
1056 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
1058 // hack as there is no real way to see has message be handled.
1059 // Previuos counter check just tells that is has been received by submgr
1060 // --> artificial delay
1061 <-time.After(1 * time.Second)
1063 // Del resp for first and second
1064 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1066 // don't care in which order responses are received
1067 xappConn1.RecvSubsDelResp(t, nil)
1068 xappConn1.RecvSubsDelResp(t, nil)
1070 //Wait that subs is cleaned
1071 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1073 xappConn1.TestMsgChanEmpty(t)
1074 xappConn2.TestMsgChanEmpty(t)
1075 e2termConn1.TestMsgChanEmpty(t)
1076 mainCtrl.wait_registry_empty(t, 10)
1079 //-----------------------------------------------------------------------------
1080 // TestSubReqAndSubDelOkTwoParallel
1083 // +-------+ +-------+ +---------+ +---------+
1084 // | xapp | | xapp | | submgr | | e2term |
1085 // +-------+ +-------+ +---------+ +---------+
1090 // | |------------->| |
1093 // | | |------------->|
1096 // |------------------------>| |
1099 // | | |------------->|
1102 // | | |<-------------|
1104 // | |<-------------| |
1107 // | | |<-------------|
1109 // |<------------------------| |
1111 // | | [SUBS 1 DELETE] |
1113 // | | [SUBS 2 DELETE] |
1116 //-----------------------------------------------------------------------------
1118 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
1119 CaseBegin("TestSubReqAndSubDelOkTwoParallel")
1122 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1124 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1125 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1128 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1131 rparams2.Req.EventTriggerDefinition.Data.Length = 1
1132 rparams2.Req.EventTriggerDefinition.Data.Data = make([]uint8, rparams2.Req.EventTriggerDefinition.Data.Length)
1133 rparams2.Req.EventTriggerDefinition.Data.Data[0] = 2
1135 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1136 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1139 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1140 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1143 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1144 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1147 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1148 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1149 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1150 xappConn1.RecvSubsDelResp(t, deltrans1)
1151 //Wait that subs is cleaned
1152 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1155 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1156 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1157 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1158 xappConn2.RecvSubsDelResp(t, deltrans2)
1159 //Wait that subs is cleaned
1160 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1162 xappConn1.TestMsgChanEmpty(t)
1163 xappConn2.TestMsgChanEmpty(t)
1164 e2termConn1.TestMsgChanEmpty(t)
1165 mainCtrl.wait_registry_empty(t, 10)
1168 //-----------------------------------------------------------------------------
1169 // TestSameSubsDiffRan
1170 // Same subscription to different RANs
1173 // +-------+ +---------+ +---------+
1174 // | xapp | | submgr | | e2term |
1175 // +-------+ +---------+ +---------+
1180 // |------------->| |
1183 // | |------------->|
1185 // | | SubResp(r1) |
1186 // | |<-------------|
1188 // | SubResp(r1) | |
1189 // |<-------------| |
1192 // |------------->| |
1195 // | |------------->|
1197 // | | SubResp(r2) |
1198 // | |<-------------|
1200 // | SubResp(r2) | |
1201 // |<-------------| |
1203 // | [SUBS r1 DELETE] |
1205 // | [SUBS r2 DELETE] |
1208 //-----------------------------------------------------------------------------
1209 func TestSameSubsDiffRan(t *testing.T) {
1210 CaseBegin("TestSameSubsDiffRan")
1213 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1214 xappConn1.SendSubsReq(t, nil, cretrans1)
1215 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1216 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1217 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1220 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
1221 xappConn1.SendSubsReq(t, nil, cretrans2)
1222 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1223 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1224 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1227 deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1228 xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
1229 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1230 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1231 xappConn1.RecvSubsDelResp(t, deltrans1)
1232 //Wait that subs is cleaned
1233 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1236 deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
1237 xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
1238 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1239 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1240 xappConn1.RecvSubsDelResp(t, deltrans2)
1241 //Wait that subs is cleaned
1242 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1244 xappConn1.TestMsgChanEmpty(t)
1245 xappConn2.TestMsgChanEmpty(t)
1246 e2termConn1.TestMsgChanEmpty(t)
1247 mainCtrl.wait_registry_empty(t, 10)
1250 //-----------------------------------------------------------------------------
1251 // TestSubReqRetryInSubmgr
1254 // +-------+ +---------+ +---------+
1255 // | xapp | | submgr | | e2term |
1256 // +-------+ +---------+ +---------+
1259 // |------------->| |
1262 // | |------------->|
1266 // | |------------->|
1269 // | |<-------------|
1272 // |<-------------| |
1274 // | [SUBS DELETE] |
1277 //-----------------------------------------------------------------------------
1279 func TestSubReqRetryInSubmgr(t *testing.T) {
1280 CaseBegin("TestSubReqRetryInSubmgr start")
1282 // Init counter check
1283 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1284 Counter{cSubReqFromXapp, 1},
1285 Counter{cSubReqToE2, 1},
1286 Counter{cSubReqTimerExpiry, 1},
1287 Counter{cSubReReqToE2, 1},
1288 Counter{cSubRespFromE2, 1},
1289 Counter{cSubRespToXapp, 1},
1290 Counter{cSubDelReqFromXapp, 1},
1291 Counter{cSubDelReqToE2, 1},
1292 Counter{cSubDelRespFromE2, 1},
1293 Counter{cSubDelRespToXapp, 1},
1296 // Xapp: Send SubsReq
1297 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1299 // E2t: Receive 1st SubsReq
1300 e2termConn1.RecvSubsReq(t)
1302 // E2t: Receive 2nd SubsReq and send SubsResp
1303 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1304 e2termConn1.SendSubsResp(t, crereq, cremsg)
1306 // Xapp: Receive SubsResp
1307 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1309 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1310 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1311 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1312 xappConn1.RecvSubsDelResp(t, deltrans)
1314 // Wait that subs is cleaned
1315 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1317 xappConn1.TestMsgChanEmpty(t)
1318 xappConn2.TestMsgChanEmpty(t)
1319 e2termConn1.TestMsgChanEmpty(t)
1320 mainCtrl.wait_registry_empty(t, 10)
1322 mainCtrl.VerifyCounterValues(t)
1325 //-----------------------------------------------------------------------------
1326 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
1329 // +-------+ +---------+ +---------+
1330 // | xapp | | submgr | | e2term |
1331 // +-------+ +---------+ +---------+
1334 // |------------->| |
1337 // | |------------->|
1341 // | |------------->|
1344 // | |------------->|
1347 // | |<-------------|
1350 //-----------------------------------------------------------------------------
1351 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
1352 CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
1354 // Init counter check
1355 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1356 Counter{cSubReqFromXapp, 1},
1357 Counter{cSubReqToE2, 1},
1358 Counter{cSubReReqToE2, 1},
1359 Counter{cSubReqTimerExpiry, 2},
1360 Counter{cSubDelReqToE2, 1},
1361 Counter{cSubDelRespFromE2, 1},
1364 // Xapp: Send SubsReq
1365 xappConn1.SendSubsReq(t, nil, nil)
1367 // E2t: Receive 1st SubsReq
1368 e2termConn1.RecvSubsReq(t)
1370 // E2t: Receive 2nd SubsReq
1371 e2termConn1.RecvSubsReq(t)
1373 // E2t: Send receive SubsDelReq and send SubsResp
1374 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1375 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1377 // Wait that subs is cleaned
1378 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 10)
1380 xappConn1.TestMsgChanEmpty(t)
1381 xappConn2.TestMsgChanEmpty(t)
1382 e2termConn1.TestMsgChanEmpty(t)
1383 mainCtrl.wait_registry_empty(t, 10)
1385 mainCtrl.VerifyCounterValues(t)
1388 //-----------------------------------------------------------------------------
1389 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
1392 // +-------+ +---------+ +---------+
1393 // | xapp | | submgr | | e2term |
1394 // +-------+ +---------+ +---------+
1397 // |------------->| |
1400 // | |------------->|
1404 // | |------------->|
1407 // | |------------->|
1411 // | |------------->|
1415 //-----------------------------------------------------------------------------
1417 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
1418 CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
1420 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1421 Counter{cSubReqFromXapp, 1},
1422 Counter{cSubReqToE2, 1},
1423 Counter{cSubReReqToE2, 1},
1424 Counter{cSubReqTimerExpiry, 2},
1425 Counter{cSubDelReqToE2, 1},
1426 Counter{cSubDelReReqToE2, 1},
1427 Counter{cSubDelReqTimerExpiry, 2},
1430 // Xapp: Send SubsReq
1431 xappConn1.SendSubsReq(t, nil, nil)
1433 // E2t: Receive 1st SubsReq
1434 e2termConn1.RecvSubsReq(t)
1436 // E2t: Receive 2nd SubsReq
1437 e2termConn1.RecvSubsReq(t)
1439 // E2t: Receive 1st SubsDelReq
1440 e2termConn1.RecvSubsDelReq(t)
1442 // E2t: Receive 2nd SubsDelReq
1443 delreq, _ := e2termConn1.RecvSubsDelReq(t)
1445 // Wait that subs is cleaned
1446 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 15)
1448 xappConn1.TestMsgChanEmpty(t)
1449 xappConn2.TestMsgChanEmpty(t)
1450 e2termConn1.TestMsgChanEmpty(t)
1451 mainCtrl.wait_registry_empty(t, 10)
1453 mainCtrl.VerifyCounterValues(t)
1456 //-----------------------------------------------------------------------------
1457 // TestSubReqSubFailRespInSubmgr
1460 // +-------+ +---------+ +---------+
1461 // | xapp | | submgr | | e2term |
1462 // +-------+ +---------+ +---------+
1465 // |------------->| |
1468 // | |------------->|
1471 // | |<-------------|
1474 // |<-------------| |
1477 //-----------------------------------------------------------------------------
1479 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1480 CaseBegin("TestSubReqSubFailRespInSubmgr start")
1482 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1483 Counter{cSubReqFromXapp, 1},
1484 Counter{cSubReqToE2, 1},
1485 Counter{cSubFailFromE2, 1},
1486 Counter{cSubFailToXapp, 1},
1489 // Xapp: Send SubsReq
1490 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1492 // E2t: Receive SubsReq and send SubsFail (first)
1493 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1494 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1495 fparams1.Set(crereq1)
1496 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1498 // Xapp: Receive SubsFail
1499 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
1501 // Wait that subs is cleaned
1502 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1504 xappConn1.TestMsgChanEmpty(t)
1505 xappConn2.TestMsgChanEmpty(t)
1506 e2termConn1.TestMsgChanEmpty(t)
1507 mainCtrl.wait_registry_empty(t, 10)
1509 mainCtrl.VerifyCounterValues(t)
1512 //-----------------------------------------------------------------------------
1513 // TestSubDelReqRetryInSubmgr
1516 // +-------+ +---------+ +---------+
1517 // | xapp | | submgr | | e2term |
1518 // +-------+ +---------+ +---------+
1520 // | [SUBS CREATE] |
1524 // |------------->| |
1527 // | |------------->|
1530 // | |------------->|
1533 // | |<-------------|
1536 // |<-------------| |
1538 //-----------------------------------------------------------------------------
1540 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1542 CaseBegin("TestSubDelReqRetryInSubmgr start")
1545 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1546 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1547 e2termConn1.SendSubsResp(t, crereq, cremsg)
1548 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1551 // Xapp: Send SubsDelReq
1552 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1554 // E2t: Receive 1st SubsDelReq
1555 e2termConn1.RecvSubsDelReq(t)
1557 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1558 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1559 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1561 // Xapp: Receive SubsDelResp
1562 xappConn1.RecvSubsDelResp(t, deltrans)
1564 // Wait that subs is cleaned
1565 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1567 xappConn1.TestMsgChanEmpty(t)
1568 xappConn2.TestMsgChanEmpty(t)
1569 e2termConn1.TestMsgChanEmpty(t)
1570 mainCtrl.wait_registry_empty(t, 10)
1573 //-----------------------------------------------------------------------------
1574 // TestSubDelReqTwoRetriesNoRespInSubmgr
1577 // +-------+ +---------+ +---------+
1578 // | xapp | | submgr | | e2term |
1579 // +-------+ +---------+ +---------+
1581 // | [SUBS CREATE] |
1585 // |------------->| |
1588 // | |------------->|
1591 // | |------------->|
1595 // |<-------------| |
1597 //-----------------------------------------------------------------------------
1599 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1601 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
1604 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1605 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1606 e2termConn1.SendSubsResp(t, crereq, cremsg)
1607 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1610 // Xapp: Send SubsDelReq
1611 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1613 // E2t: Receive 1st SubsDelReq
1614 e2termConn1.RecvSubsDelReq(t)
1616 // E2t: Receive 2nd SubsDelReq
1617 e2termConn1.RecvSubsDelReq(t)
1619 // Xapp: Receive SubsDelResp
1620 xappConn1.RecvSubsDelResp(t, deltrans)
1622 // Wait that subs is cleaned
1623 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1625 xappConn1.TestMsgChanEmpty(t)
1626 xappConn2.TestMsgChanEmpty(t)
1627 e2termConn1.TestMsgChanEmpty(t)
1628 mainCtrl.wait_registry_empty(t, 10)
1631 //-----------------------------------------------------------------------------
1632 // TestSubDelReqSubDelFailRespInSubmgr
1635 // +-------+ +---------+ +---------+
1636 // | xapp | | submgr | | e2term |
1637 // +-------+ +---------+ +---------+
1639 // | [SUBS CREATE] |
1643 // |------------->| |
1646 // | |------------->|
1649 // | |<-------------|
1652 // |<-------------| |
1655 //-----------------------------------------------------------------------------
1657 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1658 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1660 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1661 Counter{cSubReqFromXapp, 1},
1662 Counter{cSubReqToE2, 1},
1663 Counter{cSubRespFromE2, 1},
1664 Counter{cSubRespToXapp, 1},
1665 Counter{cSubDelReqFromXapp, 1},
1666 Counter{cSubDelReqToE2, 1},
1667 Counter{cSubDelFailFromE2, 1},
1668 Counter{cSubDelRespToXapp, 1},
1672 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1673 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1674 e2termConn1.SendSubsResp(t, crereq, cremsg)
1675 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1677 // Xapp: Send SubsDelReq
1678 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1680 // E2t: Send receive SubsDelReq and send SubsDelFail
1681 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1682 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1684 // Xapp: Receive SubsDelResp
1685 xappConn1.RecvSubsDelResp(t, deltrans)
1687 // Wait that subs is cleaned
1688 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1690 xappConn1.TestMsgChanEmpty(t)
1691 xappConn2.TestMsgChanEmpty(t)
1692 e2termConn1.TestMsgChanEmpty(t)
1693 mainCtrl.wait_registry_empty(t, 10)
1695 mainCtrl.VerifyCounterValues(t)
1698 //-----------------------------------------------------------------------------
1699 // TestSubReqAndSubDelOkSameAction
1702 // +-------+ +-------+ +---------+ +---------+
1703 // | xapp2 | | xapp1 | | submgr | | e2term |
1704 // +-------+ +-------+ +---------+ +---------+
1709 // | |------------->| |
1712 // | | |------------->|
1714 // | | |<-------------|
1716 // | |<-------------| |
1719 // |--------------------------->| |
1722 // |<---------------------------| |
1724 // | | SubDelReq 1 | |
1725 // | |------------->| |
1727 // | | SubDelResp 1 | |
1728 // | |<-------------| |
1730 // | SubDelReq 2 | |
1731 // |--------------------------->| |
1733 // | | | SubDelReq 2 |
1734 // | | |------------->|
1736 // | | | SubDelReq 2 |
1737 // | | |------------->|
1739 // | SubDelResp 2 | |
1740 // |<---------------------------| |
1742 //-----------------------------------------------------------------------------
1743 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
1744 CaseBegin("TestSubReqAndSubDelOkSameAction")
1746 // Init counter check
1747 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1748 Counter{cSubReqFromXapp, 2},
1749 Counter{cSubReqToE2, 1},
1750 Counter{cSubRespFromE2, 1},
1751 Counter{cSubRespToXapp, 2},
1752 Counter{cMergedSubscriptions, 1},
1753 Counter{cUnmergedSubscriptions, 1},
1754 Counter{cSubDelReqFromXapp, 2},
1755 Counter{cSubDelReqToE2, 1},
1756 Counter{cSubDelRespFromE2, 1},
1757 Counter{cSubDelRespToXapp, 2},
1761 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1763 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1764 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1765 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1766 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1769 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1771 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1772 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1774 resp, _ := xapp.Subscription.QuerySubscriptions()
1775 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1776 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1777 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
1780 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1781 xappConn1.RecvSubsDelResp(t, deltrans1)
1784 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1785 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1786 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1787 xappConn2.RecvSubsDelResp(t, deltrans2)
1788 //Wait that subs is cleaned
1789 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1791 xappConn1.TestMsgChanEmpty(t)
1792 xappConn2.TestMsgChanEmpty(t)
1793 e2termConn1.TestMsgChanEmpty(t)
1794 mainCtrl.wait_registry_empty(t, 10)
1796 mainCtrl.VerifyCounterValues(t)
1799 //-----------------------------------------------------------------------------
1800 // TestSubReqAndSubDelOkSameActionParallel
1803 // +-------+ +-------+ +---------+ +---------+
1804 // | xapp2 | | xapp1 | | submgr | | e2term |
1805 // +-------+ +-------+ +---------+ +---------+
1810 // | |------------->| |
1813 // | | |------------->|
1815 // |--------------------------->| |
1817 // | | |<-------------|
1819 // | |<-------------| |
1822 // |<---------------------------| |
1824 // | | SubDelReq 1 | |
1825 // | |------------->| |
1827 // | | SubDelResp 1 | |
1828 // | |<-------------| |
1830 // | SubDelReq 2 | |
1831 // |--------------------------->| |
1833 // | | | SubDelReq 2 |
1834 // | | |------------->|
1836 // | | | SubDelReq 2 |
1837 // | | |------------->|
1839 // | SubDelResp 2 | |
1840 // |<---------------------------| |
1842 //-----------------------------------------------------------------------------
1843 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1844 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1847 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1849 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1850 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1853 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1855 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1858 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1859 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1862 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1865 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1866 xappConn1.RecvSubsDelResp(t, deltrans1)
1869 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1870 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1871 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1872 xappConn2.RecvSubsDelResp(t, deltrans2)
1874 //Wait that subs is cleaned
1875 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1877 xappConn1.TestMsgChanEmpty(t)
1878 xappConn2.TestMsgChanEmpty(t)
1879 e2termConn1.TestMsgChanEmpty(t)
1880 mainCtrl.wait_registry_empty(t, 10)
1883 //-----------------------------------------------------------------------------
1884 // TestSubReqAndSubDelNokSameActionParallel
1887 // +-------+ +-------+ +---------+ +---------+
1888 // | xapp2 | | xapp1 | | submgr | | e2term |
1889 // +-------+ +-------+ +---------+ +---------+
1894 // | |------------->| |
1897 // | | |------------->|
1899 // |--------------------------->| |
1901 // | | |<-------------|
1904 // | |<-------------| |
1907 // |<---------------------------| |
1909 //-----------------------------------------------------------------------------
1910 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1911 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1914 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1916 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1918 // E2t: Receive SubsReq (first)
1919 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1922 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1924 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1925 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1926 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1928 // E2t: send SubsFail (first)
1929 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1930 fparams1.Set(crereq1)
1931 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1934 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1936 xappConn2.RecvSubsFail(t, cretrans2)
1938 //Wait that subs is cleaned
1939 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1941 xappConn1.TestMsgChanEmpty(t)
1942 xappConn2.TestMsgChanEmpty(t)
1943 e2termConn1.TestMsgChanEmpty(t)
1944 mainCtrl.wait_registry_empty(t, 10)
1947 //-----------------------------------------------------------------------------
1948 // TestSubReqAndSubDelNoAnswerSameActionParallel
1951 // +-------+ +-------+ +---------+ +---------+
1952 // | xapp2 | | xapp1 | | submgr | | e2term |
1953 // +-------+ +-------+ +---------+ +---------+
1958 // | |------------->| |
1961 // | | |------------->|
1963 // |--------------------------->| |
1966 // | | |------------->|
1969 // | | | SubDelReq |
1970 // | | |------------->|
1972 // | | | SubDelResp |
1973 // | | |<-------------|
1975 //-----------------------------------------------------------------------------
1976 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1977 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1980 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1982 xappConn1.SendSubsReq(t, rparams1, nil)
1984 crereq1, _ := e2termConn1.RecvSubsReq(t)
1987 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1989 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1990 xappConn2.SendSubsReq(t, rparams2, nil)
1991 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1993 //Req1 (retransmitted)
1994 e2termConn1.RecvSubsReq(t)
1996 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1997 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1999 //Wait that subs is cleaned
2000 mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10)
2002 xappConn1.TestMsgChanEmpty(t)
2003 xappConn2.TestMsgChanEmpty(t)
2004 e2termConn1.TestMsgChanEmpty(t)
2005 mainCtrl.wait_registry_empty(t, 15)
2008 //----------------------------- Policy cases ---------------------------------
2009 //-----------------------------------------------------------------------------
2010 // TestSubReqPolicyAndSubDelOk
2013 // +-------+ +---------+ +---------+
2014 // | xapp | | submgr | | e2term |
2015 // +-------+ +---------+ +---------+
2018 // |------------->| |
2021 // | |------------->|
2024 // | |<-------------|
2027 // |<-------------| |
2031 // |------------->| |
2034 // | |------------->|
2037 // | |<-------------|
2040 // |<-------------| |
2042 //-----------------------------------------------------------------------------
2043 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
2044 CaseBegin("TestSubReqAndSubDelOk")
2046 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2048 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
2049 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2051 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2052 e2termConn1.SendSubsResp(t, crereq, cremsg)
2053 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2054 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2055 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2057 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2058 xappConn1.RecvSubsDelResp(t, deltrans)
2060 //Wait that subs is cleaned
2061 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2063 xappConn1.TestMsgChanEmpty(t)
2064 xappConn2.TestMsgChanEmpty(t)
2065 e2termConn1.TestMsgChanEmpty(t)
2066 mainCtrl.wait_registry_empty(t, 10)
2069 //-----------------------------------------------------------------------------
2070 // TestSubReqPolicyChangeAndSubDelOk
2073 // +-------+ +---------+ +---------+
2074 // | xapp | | submgr | | e2term |
2075 // +-------+ +---------+ +---------+
2078 // |------------->| |
2081 // | |------------->|
2084 // | |<-------------|
2087 // |<-------------| |
2090 // |------------->| |
2093 // | |------------->|
2096 // | |<-------------|
2099 // |<-------------| |
2102 // |------------->| |
2105 // | |------------->|
2108 // | |<-------------|
2111 // |<-------------| |
2113 //-----------------------------------------------------------------------------
2115 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
2116 CaseBegin("TestSubReqAndSubDelOk")
2118 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2120 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
2121 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2123 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2124 e2termConn1.SendSubsResp(t, crereq, cremsg)
2125 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2128 rparams1.Req.RequestId.InstanceId = e2SubsId
2129 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
2130 xappConn1.SendSubsReq(t, rparams1, cretrans)
2132 crereq, cremsg = e2termConn1.RecvSubsReq(t)
2133 e2termConn1.SendSubsResp(t, crereq, cremsg)
2134 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2135 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2136 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2138 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2139 xappConn1.RecvSubsDelResp(t, deltrans)
2141 //Wait that subs is cleaned
2142 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2144 xappConn1.TestMsgChanEmpty(t)
2145 xappConn2.TestMsgChanEmpty(t)
2146 e2termConn1.TestMsgChanEmpty(t)
2147 mainCtrl.wait_registry_empty(t, 10)
2150 //-----------------------------------------------------------------------------
2151 // TestSubReqAndSubDelOkTwoE2termParallel
2154 // +-------+ +---------+ +---------+ +---------+
2155 // | xapp | | submgr | | e2term1 | | e2term2 |
2156 // +-------+ +---------+ +---------+ +---------+
2161 // |------------->| | |
2164 // | |------------->| |
2167 // |------------->| | |
2170 // | |---------------------------->|
2173 // | |<-------------| |
2175 // |<-------------| | |
2177 // | |<----------------------------|
2179 // |<-------------| | |
2181 // | [SUBS 1 DELETE] | |
2183 // | [SUBS 2 DELETE] | |
2186 //-----------------------------------------------------------------------------
2187 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
2188 CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
2191 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
2192 xappConn1.SendSubsReq(t, nil, cretrans1)
2193 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2195 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
2196 xappConn1.SendSubsReq(t, nil, cretrans2)
2197 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
2200 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2201 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2204 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
2205 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
2208 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2209 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2210 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2211 xappConn1.RecvSubsDelResp(t, deltrans1)
2212 //Wait that subs is cleaned
2213 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
2216 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
2217 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
2218 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
2219 xappConn1.RecvSubsDelResp(t, deltrans2)
2220 //Wait that subs is cleaned
2221 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2223 xappConn1.TestMsgChanEmpty(t)
2224 xappConn2.TestMsgChanEmpty(t)
2225 e2termConn1.TestMsgChanEmpty(t)
2226 e2termConn2.TestMsgChanEmpty(t)
2227 mainCtrl.wait_registry_empty(t, 10)
2230 //-----------------------------------------------------------------------------
2231 // TestSubReqInsertAndSubDelOk
2234 // +-------+ +---------+ +---------+
2235 // | xapp | | submgr | | e2term |
2236 // +-------+ +---------+ +---------+
2239 // |------------->| |
2242 // | |------------->|
2245 // | |<-------------|
2248 // |<-------------| |
2252 // |------------->| |
2255 // | |------------->|
2258 // | |<-------------|
2261 // |<-------------| |
2263 //-----------------------------------------------------------------------------
2264 func TestSubReqInsertAndSubDelOk(t *testing.T) {
2265 CaseBegin("TestInsertSubReqAndSubDelOk")
2267 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2269 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeInsert
2270 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2272 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2273 e2termConn1.SendSubsResp(t, crereq, cremsg)
2274 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2275 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2276 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2278 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2279 xappConn1.RecvSubsDelResp(t, deltrans)
2281 //Wait that subs is cleaned
2282 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2284 xappConn1.TestMsgChanEmpty(t)
2285 xappConn2.TestMsgChanEmpty(t)
2286 e2termConn1.TestMsgChanEmpty(t)
2287 mainCtrl.wait_registry_empty(t, 10)
2290 //-----------------------------------------------------------------------------
2291 // TestSubReqRetransmissionWithSameSubIdDiffXid
2293 // This case simulates case where xApp restarts and starts sending same
2294 // subscription requests which have already subscribed successfully
2297 // +-------+ +---------+ +---------+
2298 // | xapp | | submgr | | e2term |
2299 // +-------+ +---------+ +---------+
2302 // |------------->| |
2305 // | |------------->|
2308 // | |<-------------|
2311 // |<-------------| |
2313 // | xApp restart | |
2316 // | (retrans with same xApp generated subid but diff xid)
2317 // |------------->| |
2320 // |<-------------| |
2322 // | [SUBS DELETE] |
2325 //-----------------------------------------------------------------------------
2326 func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) {
2327 CaseBegin("TestSubReqRetransmissionWithSameSubIdDiffXid")
2330 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2331 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2332 e2termConn1.SendSubsResp(t, crereq, cremsg)
2333 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2335 // xApp restart here
2336 // --> artificial delay
2337 <-time.After(1 * time.Second)
2340 cretrans = xappConn1.SendSubsReq(t, nil, nil) //Retransmitted SubReq
2341 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2344 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2345 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2346 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2347 xappConn1.RecvSubsDelResp(t, deltrans)
2349 //Wait that subs is cleaned
2350 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2352 xappConn1.TestMsgChanEmpty(t)
2353 xappConn2.TestMsgChanEmpty(t)
2354 e2termConn1.TestMsgChanEmpty(t)
2355 mainCtrl.wait_registry_empty(t, 10)
2358 //-----------------------------------------------------------------------------
2359 // TestSubReqNokAndSubDelOkWithRestartInMiddle
2362 // +-------+ +---------+ +---------+
2363 // | xapp | | submgr | | e2term |
2364 // +-------+ +---------+ +---------+
2367 // |------------->| |
2370 // | |------------->|
2375 // | Submgr restart |
2379 // | |------------->|
2382 // | |<-------------|
2385 //-----------------------------------------------------------------------------
2387 func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
2388 CaseBegin("TestSubReqNokAndSubDelOkWithRestartInMiddle")
2390 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
2391 xappConn1.SendSubsReq(t, nil, nil)
2392 e2termConn1.RecvSubsReq(t)
2393 mainCtrl.SetResetTestFlag(t, false)
2395 resp, _ := xapp.Subscription.QuerySubscriptions()
2396 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2397 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2398 e2SubsId := uint32(resp[0].SubscriptionID)
2399 t.Logf("e2SubsId = %v", e2SubsId)
2401 mainCtrl.SimulateRestart(t)
2402 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2404 // Submgr send delete for uncompleted subscription
2405 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2406 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2408 // Wait that subs is cleaned
2409 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2411 xappConn1.TestMsgChanEmpty(t)
2412 xappConn2.TestMsgChanEmpty(t)
2413 e2termConn1.TestMsgChanEmpty(t)
2414 mainCtrl.wait_registry_empty(t, 10)
2417 //-----------------------------------------------------------------------------
2418 // TestSubReqAndSubDelOkWithRestartInMiddle
2421 // +-------+ +---------+ +---------+
2422 // | xapp | | submgr | | e2term |
2423 // +-------+ +---------+ +---------+
2426 // |------------->| |
2429 // | |------------->|
2432 // | |<-------------|
2435 // |<-------------| |
2438 // | Submgr restart |
2441 // |------------->| |
2444 // | |------------->|
2447 // | |<-------------|
2450 // |<-------------| |
2452 //-----------------------------------------------------------------------------
2454 func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
2455 CaseBegin("TestSubReqAndSubDelOkWithRestartInMiddle")
2457 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2458 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2459 e2termConn1.SendSubsResp(t, crereq, cremsg)
2460 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2462 // Check subscription
2463 resp, _ := xapp.Subscription.QuerySubscriptions()
2464 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2465 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2466 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2468 mainCtrl.SimulateRestart(t)
2469 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2471 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
2472 // That needs to be completed before successful subscription query is possible
2473 <-time.After(time.Second * 1)
2475 // Check that subscription is restored correctly after restart
2476 resp, _ = xapp.Subscription.QuerySubscriptions()
2477 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2478 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2479 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2481 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2482 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2483 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2484 xappConn1.RecvSubsDelResp(t, deltrans)
2486 //Wait that subs is cleaned
2487 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2489 xappConn1.TestMsgChanEmpty(t)
2490 xappConn2.TestMsgChanEmpty(t)
2491 e2termConn1.TestMsgChanEmpty(t)
2492 mainCtrl.wait_registry_empty(t, 10)
2495 //-----------------------------------------------------------------------------
2496 // TestSubReqAndSubDelOkSameActionWithRestartsInMiddle
2499 // +-------+ +-------+ +---------+ +---------+
2500 // | xapp2 | | xapp1 | | submgr | | e2term |
2501 // +-------+ +-------+ +---------+ +---------+
2506 // | |------------->| |
2509 // | | |------------->|
2511 // | | |<-------------|
2513 // | |<-------------| |
2516 // | submgr restart |
2521 // |--------------------------->| |
2524 // |<---------------------------| |
2526 // | | SubDelReq 1 | |
2527 // | |------------->| |
2529 // | | SubDelResp 1 | |
2530 // | |<-------------| |
2534 // | submgr restart |
2537 // | SubDelReq 2 | |
2538 // |--------------------------->| |
2540 // | | | SubDelReq 2 |
2541 // | | |------------->|
2543 // | | | SubDelReq 2 |
2544 // | | |------------->|
2546 // | SubDelResp 2 | |
2547 // |<---------------------------| |
2549 //-----------------------------------------------------------------------------
2551 func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
2552 CaseBegin("TestSubReqAndSubDelOkSameActionWithRestartsInMiddle")
2555 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2557 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2558 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2559 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2560 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2563 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2565 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2566 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
2568 // Check subscription
2569 resp, _ := xapp.Subscription.QuerySubscriptions()
2570 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2571 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2572 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2574 mainCtrl.SimulateRestart(t)
2575 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2577 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
2578 // That needs to be completed before successful subscription query is possible
2579 <-time.After(time.Second * 1)
2581 // Check that subscription is restored correctly after restart
2582 resp, _ = xapp.Subscription.QuerySubscriptions()
2583 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2584 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2585 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2588 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2589 xapp.Logger.Debug("xappConn1.RecvSubsDelResp")
2590 xappConn1.RecvSubsDelResp(t, deltrans1)
2591 xapp.Logger.Debug("xappConn1.RecvSubsDelResp received")
2593 mainCtrl.SimulateRestart(t)
2594 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2596 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
2597 // Submgr need be ready before successful subscription deletion is possible
2598 <-time.After(time.Second * 1)
2601 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
2602 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2604 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2605 xappConn2.RecvSubsDelResp(t, deltrans2)
2607 //Wait that subs is cleaned
2608 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2610 xappConn1.TestMsgChanEmpty(t)
2611 xappConn2.TestMsgChanEmpty(t)
2612 e2termConn1.TestMsgChanEmpty(t)
2613 mainCtrl.wait_registry_empty(t, 10)
2616 //*****************************************************************************
2617 // REST interface test cases
2618 //*****************************************************************************
2620 //-----------------------------------------------------------------------------
2621 // Test debug GET and POST requests
2624 // +-------+ +---------+
2625 // | user | | submgr |
2626 // +-------+ +---------+
2633 func TestGetSubscriptions(t *testing.T) {
2635 mainCtrl.sendGetRequest(t, "localhost:8088", "/ric/v1/subscriptions")
2638 func TestGetSymptomData(t *testing.T) {
2640 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/symptomdata")
2643 func TestPostdeleteSubId(t *testing.T) {
2645 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/deletesubid=1")
2648 func TestPostEmptyDb(t *testing.T) {
2650 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/emptydb")
2653 func TestGetRestSubscriptions(t *testing.T) {
2655 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/restsubscriptions")
2658 //-----------------------------------------------------------------------------
2659 // TestRESTSubReqAndRouteNok
2662 // +-------+ +---------+ +---------+
2663 // | xapp | | submgr | | rtmgr |
2664 // +-------+ +---------+ +---------+
2667 // |---------------->| |
2669 // | RESTSubResp | |
2670 // |<----------------| |
2671 // | | RouteCreate |
2672 // | |------------->|
2673 // | | RouteCreate |
2675 // | |(Bad request) |
2676 // | |<-------------|
2678 // |<----------------| |
2680 // | [SUBS INT DELETE] |
2682 // | RESTSubDelReq | |
2683 // |---------------->| |
2684 // | RESTSubDelResp | |
2685 // |<----------------| |
2687 //-----------------------------------------------------------------------------
2688 func TestRESTSubReqAndRouteNok(t *testing.T) {
2690 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2691 Counter{cRestSubReqFromXapp, 1},
2692 Counter{cRestSubRespToXapp, 1},
2693 Counter{cRouteCreateFail, 1},
2694 Counter{cRestSubFailNotifToXapp, 1},
2695 Counter{cRestSubDelReqFromXapp, 1},
2696 Counter{cRestSubDelRespToXapp, 1},
2699 const subReqCount int = 1
2701 // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
2702 waiter := rtmgrHttp.AllocNextSleep(50, false)
2703 newSubsId := mainCtrl.get_registry_next_subid(t)
2706 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2707 restSubId := xappConn1.SendRESTSubsReq(t, params)
2708 xappConn1.ExpectRESTNotificationNok(t, restSubId, "failAll")
2709 waiter.WaitResult(t)
2711 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2712 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
2715 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2717 // Wait that subs is cleaned
2718 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2719 waitSubsCleanup(t, e2SubsId, 10)
2720 mainCtrl.VerifyCounterValues(t)
2721 mainCtrl.VerifyAllClean(t)
2724 //-----------------------------------------------------------------------------
2725 // TestRESTSubReqAndRouteUpdateNok
2727 // stub stub stub stub
2728 // +-------+ +-------+ +---------+ +---------+ +---------+
2729 // | xapp1 | | xapp2 | | submgr | | rtmgr | | e2term |
2730 // +-------+ +-------+ +---------+ +---------+ +---------+
2732 // | RESTSubReq1 | | |
2733 // |------------------------>| | |
2734 // | RESTSubResp2 | | |
2735 // |<------------------------| | |
2737 // | | | RouteCreate | |
2738 // | | |------------->| |
2739 // | | | CreateResp | |
2740 // | | |<-------------| |
2742 // | | |---------------------------->|
2743 // | | | SubResp | |
2744 // | | |<----------------------------|
2745 // | RESTNotif1 | | |
2746 // |<------------------------| | |
2748 // | | RESTSubReq2 | | |
2749 // | |------------>| | |
2750 // | | RESTSubResp2| | |
2751 // | |<------------| | |
2752 // | | | RouteUpdate | |
2753 // | | |------------->| |
2754 // | | | RouteUpdate | |
2755 // | | | status:400 | |
2756 // | | |(Bad request) | |
2757 // | | |<-------------| |
2758 // | | RESTNotif2(unsuccessful) | |
2759 // | |<------------| | |
2761 // | [SUBS INT DELETE] | |
2763 // | RESTSubDelReq1 | | |
2764 // |------------------------>| | |
2765 // | RESTSubDelResp1 | | |
2766 // |<------------------------| | |
2768 // | | | [SUBS DELETE] |
2770 //-----------------------------------------------------------------------------
2771 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
2773 //Init counter check
2774 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2775 Counter{cRestSubReqFromXapp, 2},
2776 Counter{cRestSubRespToXapp, 2},
2777 Counter{cSubReqToE2, 1},
2778 Counter{cSubRespFromE2, 1},
2779 Counter{cRestSubNotifToXapp, 1},
2780 Counter{cRestSubFailNotifToXapp, 1},
2781 Counter{cRouteCreateUpdateFail, 1},
2782 Counter{cRestSubDelReqFromXapp, 2},
2783 Counter{cSubDelReqToE2, 1},
2784 Counter{cSubDelRespFromE2, 1},
2785 Counter{cRestSubDelRespToXapp, 2},
2788 var params *teststube2ap.RESTSubsReqParams = nil
2790 // Subs create for xapp1
2791 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2793 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2795 // xapp2 ROUTE creation shall fail with 400 from rtmgr -> submgr
2796 waiter := rtmgrHttp.AllocNextEvent(false)
2797 newSubsId := mainCtrl.get_registry_next_subid(t)
2798 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
2799 params.SetMeid("RAN_NAME_1")
2800 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2801 xapp.Logger.Debug("Send REST subscriber request for second subscriber : %v", restSubId2)
2802 xappConn2.ExpectRESTNotificationNok(t, restSubId2, "allFail")
2803 waiter.WaitResult(t)
2804 xappConn2.WaitRESTNotification(t, restSubId2)
2806 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2808 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2809 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
2811 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2812 //Wait that subs is cleaned
2813 waitSubsCleanup(t, e2SubsId, 10)
2815 mainCtrl.VerifyCounterValues(t)
2816 mainCtrl.VerifyAllClean(t)
2819 //-----------------------------------------------------------------------------
2820 // TestRESTSubDelReqAndRouteDeleteNok
2823 // +-------+ +---------+ +---------+ +---------+
2824 // | xapp | | submgr | | rtmgr | | e2term |
2825 // +-------+ +---------+ +---------+ +---------+
2827 // | RESTSubReq | | |
2828 // |---------------->| | |
2830 // | RESTSubResp | | |
2831 // |<----------------| | |
2833 // | |---------------------------->|
2835 // | |<----------------------------|
2836 // | RESTNotif | | |
2837 // |<----------------| | |
2840 // | RESTSubDelReq | | |
2841 // |---------------->| | |
2842 // | RESTSubDelResp | | |
2843 // |<----------------| | |
2844 // | | SubSelReq | |
2845 // | |---------------------------->|
2846 // | | SubSelResp | |
2847 // | |<----------------------------|
2848 // | | RouteDelete | |
2849 // | |------------->| |
2850 // | | Routedelete | |
2851 // | | status:400 | |
2852 // | |(Bad request) | |
2853 // | |<-------------| |
2855 //-----------------------------------------------------------------------------
2857 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
2859 // Init counter check
2860 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2861 Counter{cRestSubReqFromXapp, 1},
2862 Counter{cRestSubRespToXapp, 1},
2863 Counter{cSubReqToE2, 1},
2864 Counter{cSubRespFromE2, 1},
2865 Counter{cRestSubNotifToXapp, 1},
2866 Counter{cRestSubDelReqFromXapp, 1},
2867 Counter{cRouteDeleteFail, 1},
2868 Counter{cSubDelReqToE2, 1},
2869 Counter{cSubDelRespFromE2, 1},
2870 Counter{cRestSubDelRespToXapp, 1},
2873 var params *teststube2ap.RESTSubsReqParams = nil
2876 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2878 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2880 waiter := rtmgrHttp.AllocNextEvent(false)
2881 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2882 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2883 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2884 waiter.WaitResult(t)
2886 waitSubsCleanup(t, e2SubsId, 10)
2887 mainCtrl.VerifyCounterValues(t)
2888 mainCtrl.VerifyAllClean(t)
2891 //-----------------------------------------------------------------------------
2892 // TestRESTSubMergeDelAndRouteUpdateNok
2894 // stub stub stub stub
2895 // +-------+ +-------+ +---------+ +---------+ +---------+
2896 // | xapp1 | | xapp2 | | submgr | | rtmgr | | e2term |
2897 // +-------+ +-------+ +---------+ +---------+ +---------+
2899 // | RESTSubReq1 | | |
2900 // |------------------------>| | |
2901 // | RESTSubResp2 | | |
2902 // |<------------------------| | |
2904 // | | | RouteCreate | |
2905 // | | |------------->| |
2906 // | | | CreateResp | |
2907 // | | |<-------------| |
2909 // | | |---------------------------->|
2910 // | | | SubResp | |
2911 // | | |<----------------------------|
2912 // | RESTNotif1 | | |
2913 // |<------------------------| | |
2915 // | | RESTSubReq2 | | |
2916 // | |------------>| | |
2917 // | | RESTSubResp2| | |
2918 // | |<------------| | |
2919 // | | | RouteCreate | |
2920 // | | |------------->| |
2921 // | | | CreateResp | |
2922 // | | |<-------------| |
2924 // | | |---------------------------->|
2925 // | | | SubResp | |
2926 // | | |<----------------------------|
2927 // | | RESTNotif2 | | |
2928 // | |<------------| | |
2930 // | [SUBS INT DELETE] | |
2932 // | RESTSubDelReq1 | | |
2933 // |------------------------>| | |
2934 // | RESTSubDelResp1 | | |
2935 // |<------------------------| | |
2936 // | | | SubDelReq | |
2937 // | | |---------------------------->|
2938 // | | | SubDelResp | |
2939 // | | |<----------------------------|
2940 // | | | RouteUpdate | |
2941 // | | |------------->| |
2942 // | | | RouteUpdate | |
2943 // | | | status:400 | |
2944 // | | |(Bad request) | |
2945 // | | |<-------------| |
2947 // | | RESTSubDelReq2 | |
2948 // | |------------>| | |
2949 // | | RESTSubDelResp2 | |
2950 // | |<------------| | |
2951 // | | | SubDelReq | |
2952 // | | |---------------------------->|
2953 // | | | SubdelResp | |
2954 // | | |<----------------------------|
2955 // | | | RouteDelete | |
2956 // | | |------------->| |
2957 // | | | Deleteresp | |
2958 // | | |<-------------| |
2960 //-----------------------------------------------------------------------------
2962 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
2964 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2965 Counter{cRestSubReqFromXapp, 2},
2966 Counter{cMergedSubscriptions, 1},
2967 Counter{cRestSubRespToXapp, 2},
2968 Counter{cSubReqToE2, 1},
2969 Counter{cSubRespFromE2, 1},
2970 Counter{cRestSubNotifToXapp, 2},
2971 Counter{cRestSubDelReqFromXapp, 2},
2972 Counter{cRouteDeleteUpdateFail, 1},
2973 Counter{cSubDelReqToE2, 1},
2974 Counter{cSubDelRespFromE2, 1},
2975 Counter{cRestSubDelRespToXapp, 2},
2976 Counter{cUnmergedSubscriptions, 1},
2979 var params *teststube2ap.RESTSubsReqParams = nil
2982 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2984 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2985 restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1")
2987 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
2989 //Del1, this shall fail on rtmgr side
2990 waiter := rtmgrHttp.AllocNextEvent(false)
2991 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2992 waiter.WaitResult(t)
2994 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"})
2997 deleteXapp2Subscription(t, &restSubId2)
2999 waitSubsCleanup(t, e2SubsId2, 10)
3000 mainCtrl.VerifyCounterValues(t)
3001 mainCtrl.VerifyAllClean(t)
3004 //-----------------------------------------------------------------------------
3005 // TestRESTSubReqRetransmission
3008 // +-------+ +---------+ +---------+
3009 // | xapp | | submgr | | e2term |
3010 // +-------+ +---------+ +---------+
3012 // | RESTSubReq1 | |
3013 // |---------------->| |
3015 // | RESTSubResp | |
3016 // |<----------------| |
3018 // | |------------->|
3020 // | RESTSubReq2 | |
3022 // |---------------->| |
3023 // | RESTSubResp(201)| |
3024 // |<----------------| |
3027 // | |<-------------|
3029 // |<----------------| |
3031 // | [SUBS DELETE] |
3034 //-----------------------------------------------------------------------------
3036 func TestRESTSubReqRetransmission(t *testing.T) {
3038 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3039 Counter{cRestSubReqFromXapp, 2},
3040 Counter{cRestSubRespToXapp, 2},
3041 Counter{cSubReqToE2, 1},
3042 Counter{cSubRespFromE2, 1},
3043 Counter{cRestSubNotifToXapp, 1},
3044 Counter{cRestSubDelReqFromXapp, 1},
3045 Counter{cSubDelReqToE2, 1},
3046 Counter{cSubDelRespFromE2, 1},
3047 Counter{cRestSubDelRespToXapp, 1},
3049 // Retry/duplicate will get the same way as the first request.
3050 // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
3051 // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
3054 const subReqCount int = 1
3056 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3057 restSubId := xappConn1.SendRESTSubsReq(t, params)
3059 xappConn1.SendRESTSubsReq(t, params)
3060 <-time.After(time.Second * 1)
3062 xappConn1.WaitListedRestNotifications(t, []string{restSubId})
3064 // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
3065 // the order is not significant here.
3066 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3067 e2termConn1.SendSubsResp(t, crereq, cremsg)
3069 e2SubsId := <-xappConn1.ListedRESTNotifications
3071 xapp.Logger.Debug("TEST: XAPP notification received e2SubsId=%v", e2SubsId)
3074 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3075 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3076 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3078 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsId.E2SubsId}, 10)
3080 mainCtrl.VerifyCounterValues(t)
3081 mainCtrl.VerifyAllClean(t)
3084 //-----------------------------------------------------------------------------
3086 // +-------+ +---------+ +---------+ +---------+
3087 // | xapp | | submgr | | e2term | | rtmgr |
3088 // +-------+ +---------+ +---------+ +---------+
3090 // | RESTSubReq | | |
3091 // |---------------->| | |
3092 // | RESTSubResp | | |
3093 // |<----------------| | |
3094 // | | RouteCreate | |
3095 // | |--------------------------->|
3096 // | | RouteResponse| |
3097 // | |<---------------------------| // The order of these events may vary
3099 // | |------------->| | // The order of these events may vary
3101 // | |<-------------| |
3102 // | RESTNotif1 | | |
3103 // |<----------------| | |
3104 // | RESTSubReq | | |
3105 // | [RETRANS1] | | |
3106 // |---------------->| | |
3107 // | RESTNotif1 | | |
3108 // |<----------------| | |
3109 // | RESTSubReq | | |
3110 // | [RETRANS2] | | |
3111 // |---------------->| | |
3112 // | RESTNotif1 | | |
3113 // |<----------------| | |
3114 // | RESTSubDelReq | | |
3115 // |---------------->| | |
3116 // | | SubDelReq | |
3117 // | |------------->| |
3118 // | RESTSubDelResp| | |
3119 // |<----------------| | |
3120 // | | SubDelResp | |
3121 // | |<-------------| |
3124 //-----------------------------------------------------------------------------
3126 func TestRESTSubReqRetransmissionV2(t *testing.T) {
3128 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3129 Counter{cRestSubReqFromXapp, 3},
3130 Counter{cDuplicateE2SubReq, 2},
3131 Counter{cRestSubRespToXapp, 3},
3132 Counter{cSubReqToE2, 1},
3133 Counter{cSubRespFromE2, 1},
3134 Counter{cRestSubNotifToXapp, 3},
3135 Counter{cRestSubDelReqFromXapp, 1},
3136 Counter{cSubDelReqToE2, 1},
3137 Counter{cSubDelRespFromE2, 1},
3138 Counter{cRestSubDelRespToXapp, 1},
3141 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3143 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3145 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3147 mainCtrl.WaitOngoingRequestMapEmpty()
3150 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
3152 assert.Equal(t, restSubId_resend, restSubId)
3154 mainCtrl.WaitOngoingRequestMapEmpty()
3157 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3159 assert.Equal(t, restSubId_resend2, restSubId)
3161 mainCtrl.WaitOngoingRequestMapEmpty()
3163 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3165 waitSubsCleanup(t, e2SubsId, 10)
3166 mainCtrl.VerifyCounterValues(t)
3167 mainCtrl.VerifyAllClean(t)
3170 //-----------------------------------------------------------------------------
3172 // +-------+ +---------+ +---------+ +---------+
3173 // | xapp | | submgr | | e2term | | rtmgr |
3174 // +-------+ +---------+ +---------+ +---------+
3176 // | RESTSubReq | | |
3177 // |---------------->| | |
3178 // | RESTSubResp | | |
3179 // |<----------------| | |
3180 // | | RouteCreate | |
3181 // | |--------------------------->|
3182 // | | RouteResponse| |
3183 // | |<---------------------------| // The order of these events may vary
3185 // | |------------->| | // The order of these events may vary
3187 // | |<-------------| |
3188 // | RESTNotif1 | | |
3189 // |<----------------| | |
3190 // | RESTSubReq | | |
3191 // | [RETRANS, with RESTsubsId] | |
3192 // |---------------->| | |
3193 // | RESTNotif1 | | |
3194 // |<----------------| | |
3195 // | RESTSubReq | | |
3196 // | [RETRANS, without RESTsubsId] | |
3197 // |---------------->| | |
3198 // | RESTNotif1 | | |
3199 // |<----------------| | |
3200 // | RESTSubDelReq | | |
3201 // |---------------->| | |
3202 // | | SubDelReq | |
3203 // | |------------->| |
3204 // | RESTSubDelResp| | |
3205 // |<----------------| | |
3206 // | | SubDelResp | |
3207 // | |<-------------| |
3210 //-----------------------------------------------------------------------------
3211 func TestRESTSubReqRetransmissionV3(t *testing.T) {
3213 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3214 Counter{cRestSubReqFromXapp, 3},
3215 Counter{cDuplicateE2SubReq, 2},
3216 Counter{cRestSubRespToXapp, 3},
3217 Counter{cSubReqToE2, 1},
3218 Counter{cSubRespFromE2, 1},
3219 Counter{cRestSubNotifToXapp, 3},
3220 Counter{cRestSubDelReqFromXapp, 1},
3221 Counter{cSubDelReqToE2, 1},
3222 Counter{cSubDelRespFromE2, 1},
3223 Counter{cRestSubDelRespToXapp, 1},
3226 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3228 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3230 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3232 mainCtrl.WaitOngoingRequestMapEmpty()
3234 //1.st resend with subscription ID
3235 params.SetSubscriptionID(&restSubId)
3236 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
3238 assert.Equal(t, restSubId_resend, restSubId)
3240 mainCtrl.WaitOngoingRequestMapEmpty()
3242 //2.nd resend without subscription ID (faking app restart)
3243 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3244 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3246 assert.Equal(t, restSubId_resend2, restSubId)
3248 mainCtrl.WaitOngoingRequestMapEmpty()
3250 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3252 waitSubsCleanup(t, e2SubsId, 10)
3253 mainCtrl.VerifyCounterValues(t)
3254 mainCtrl.VerifyAllClean(t)
3257 //-----------------------------------------------------------------------------
3259 // +-------+ +---------+ +---------+ +---------+
3260 // | xapp | | submgr | | e2term | | rtmgr |
3261 // +-------+ +---------+ +---------+ +---------+
3263 // | RESTSubReq | | |
3264 // |---------------->| | |
3265 // | RESTSubResp | | |
3266 // |<----------------| | |
3267 // | | RouteCreate | |
3268 // | |--------------------------->|
3269 // | | RouteResponse| |
3270 // | |<---------------------------|
3272 // | |------------->| |
3274 // | |<-------------| |
3275 // | RESTNotif1 | | |
3276 // |<----------------| | |
3277 // | RESTSubReq | | |
3278 // | [with RestSUbsId + one additional e2 subDetail]
3279 // |---------------->| | |
3280 // | RESTNotif1 | | |
3281 // | [for initial e2 subDetail] | |
3282 // |<----------------| | |
3283 // | | RouteCreate | |
3284 // | |--------------------------->|
3285 // | | RouteResponse| |
3286 // | |<---------------------------|
3288 // | |------------->| |
3290 // | |<-------------| |
3291 // | RESTNotif1 | | |
3292 // |<----------------| | |
3293 // | RESTSubReq | | |
3294 // | [with RESTsubsId initial request] |
3295 // |---------------->| | |
3296 // | RESTNotif1 | | |
3297 // |<----------------| | |
3298 // | RESTSubDelReq | | |
3299 // |---------------->| | |
3300 // | RESTSubDelResp| | |
3301 // |<----------------| | |
3302 // | | SubDelReq | |
3303 // | |------------->| |
3304 // | | SubDelResp | |
3305 // | |<-------------| |
3306 // | | SubDelReq | |
3307 // | |------------->| |
3308 // | | SubDelResp | |
3309 // | |<-------------| |
3312 //-----------------------------------------------------------------------------
3314 func TestRESTSubReqRetransmissionV4(t *testing.T) {
3316 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3317 Counter{cRestSubReqFromXapp, 3},
3318 Counter{cDuplicateE2SubReq, 2},
3319 Counter{cRestSubRespToXapp, 3},
3320 Counter{cSubReqToE2, 2},
3321 Counter{cSubRespFromE2, 2},
3322 Counter{cRestSubNotifToXapp, 4},
3323 Counter{cRestSubDelReqFromXapp, 1},
3324 Counter{cSubDelReqToE2, 2},
3325 Counter{cSubDelRespFromE2, 2},
3326 Counter{cRestSubDelRespToXapp, 1},
3329 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3331 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3333 mainCtrl.WaitOngoingRequestMapEmpty()
3335 // Send modified requst, this time with e2 subscriptions.
3336 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3337 params2.SetSubscriptionID(&restSubId)
3339 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3340 xappConn1.ExpectAnyNotification(t)
3341 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3342 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3343 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3344 assert.Equal(t, e2SubsId, e2SubsId1)
3346 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3348 xappConn1.DecrementRequestCount()
3349 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3350 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3351 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3352 assert.NotEqual(t, e2SubsId2, 0)
3354 mainCtrl.WaitOngoingRequestMapEmpty()
3356 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3357 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3358 params.SetSubscriptionID(&restSubId)
3359 xappConn1.ExpectAnyNotification(t)
3360 // Resend the original request again with only one e2 subscription (detail), this time with restsubsid
3361 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3362 assert.Equal(t, restSubId_resend, restSubId_resend2)
3364 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3365 assert.Equal(t, e2SubsId, e2SubsId1)
3367 mainCtrl.WaitOngoingRequestMapEmpty()
3369 // Delete both e2 subscriptions
3370 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3371 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3372 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3374 waitSubsCleanup(t, e2SubsId, 10)
3375 mainCtrl.VerifyCounterValues(t)
3376 mainCtrl.VerifyAllClean(t)
3379 //-----------------------------------------------------------------------------
3381 // +-------+ +---------+ +---------+ +---------+
3382 // | xapp | | submgr | | e2term | | rtmgr |
3383 // +-------+ +---------+ +---------+ +---------+
3385 // | RESTSubReq | | |
3386 // |---------------->| | |
3387 // | RESTSubResp | | |
3388 // |<----------------| | |
3389 // | | RouteCreate | |
3390 // | |--------------------------->|
3391 // | | RouteResponse| |
3392 // | |<---------------------------|
3394 // | |------------->| |
3396 // | |<-------------| |
3397 // | RESTNotif1 | | |
3398 // |<----------------| | |
3399 // | RESTSubReq | | |
3400 // | [with RestSUbsId + one additional e2 subDetail]
3401 // |---------------->| | |
3402 // | RESTNotif1 | | |
3403 // | [for initial e2 subDetail] | |
3404 // |<----------------| | |
3405 // | | RouteCreate | |
3406 // | |--------------------------->|
3407 // | | RouteResponse| |
3408 // | |<---------------------------|
3410 // | |------------->| |
3412 // | |<-------------| |
3413 // | RESTNotif1 | | |
3414 // |<----------------| | |
3415 // | RESTSubReq | | |
3416 // | [without RESTsubsId initial request] |
3417 // |---------------->| | |
3418 // | RESTNotif1 | | |
3419 // |<----------------| | |
3420 // | RESTSubDelReq | | |
3421 // |---------------->| | |
3422 // | RESTSubDelResp| | |
3423 // |<----------------| | |
3424 // | | SubDelReq | |
3425 // | |------------->| |
3426 // | | SubDelResp | |
3427 // | |<-------------| |
3428 // | | SubDelReq | |
3429 // | |------------->| |
3430 // | | SubDelResp | |
3431 // | |<-------------| |
3434 //-----------------------------------------------------------------------------
3436 func TestRESTSubReqRetransmissionV5(t *testing.T) {
3438 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3439 Counter{cRestSubReqFromXapp, 3},
3440 Counter{cDuplicateE2SubReq, 2},
3441 Counter{cRestSubRespToXapp, 3},
3442 Counter{cSubReqToE2, 2},
3443 Counter{cSubRespFromE2, 2},
3444 Counter{cRestSubNotifToXapp, 4},
3445 Counter{cRestSubDelReqFromXapp, 1},
3446 Counter{cSubDelReqToE2, 2},
3447 Counter{cSubDelRespFromE2, 2},
3448 Counter{cRestSubDelRespToXapp, 1},
3451 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3453 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3455 mainCtrl.WaitOngoingRequestMapEmpty()
3457 // Send modified request, this time with e2 subscriptions.
3458 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3459 params2.SetSubscriptionID(&restSubId)
3461 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3462 xappConn1.ExpectAnyNotification(t)
3463 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3464 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3466 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3467 assert.Equal(t, e2SubsId, e2SubsId1)
3468 // The first E2 subscription returns immediately, manually decrement expected request count for the remaining request handling
3469 xappConn1.DecrementRequestCount()
3471 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3473 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3474 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3475 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3476 assert.NotEqual(t, e2SubsId2, 0)
3478 mainCtrl.WaitOngoingRequestMapEmpty()
3480 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3481 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3482 xappConn1.ExpectAnyNotification(t)
3483 // Resend the original request again with only one e2 subscription (detail), WITHOUT restsubsid
3484 // md5sum shall find the original request
3485 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3486 assert.Equal(t, restSubId_resend, restSubId_resend2)
3488 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3489 assert.Equal(t, e2SubsId, e2SubsId1)
3491 mainCtrl.WaitOngoingRequestMapEmpty()
3493 // Delete both e2 subscriptions
3494 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3495 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3496 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3498 waitSubsCleanup(t, e2SubsId, 10)
3499 mainCtrl.VerifyCounterValues(t)
3500 mainCtrl.VerifyAllClean(t)
3503 //-----------------------------------------------------------------------------
3505 // +-------+ +---------+ +---------+ +---------+
3506 // | xapp | | submgr | | e2term | | rtmgr |
3507 // +-------+ +---------+ +---------+ +---------+
3509 // | RESTSubReq | | |
3510 // |---------------->| | |
3511 // | RESTSubResp | | |
3512 // |<----------------| | |
3513 // | | RouteCreate | |
3514 // | |--------------------------->|
3515 // | | RouteResponse| |
3516 // | |<---------------------------|
3518 // | |------------->| |
3520 // | |<-------------| |
3521 // | RESTNotif1 | | |
3522 // |<----------------| | |
3523 // | RESTSubReq | | |
3524 // | [with RestSUbsId + one additional e2 subDetail]
3525 // |---------------->| | |
3526 // | RESTNotif1 | | |
3527 // | [for initial e2 subDetail] | |
3528 // |<----------------| | |
3529 // | | RouteCreate | |
3530 // | |--------------------------->|
3531 // | | RouteResponse| |
3532 // | |<---------------------------|
3534 // | |------------->| |
3536 // | |<-------------| |
3537 // | RESTNotif1 | | |
3538 // |<----------------| | |
3539 // | RESTSubDelReq | | |
3540 // |---------------->| | |
3541 // | RESTSubDelResp| | |
3542 // |<----------------| | |
3543 // | | SubDelReq | |
3544 // | |------------->| |
3545 // | | SubDelResp | |
3546 // | |<-------------| |
3547 // | | SubDelReq | |
3548 // | |------------->| |
3549 // | | SubDelResp | |
3550 // | |<-------------| |
3551 // | RESTSubReq | | |
3552 // | [with RESTsubsId initial request] |
3553 // |---------------->| | |
3554 // | RESTSubResp | | |
3555 // |<----------------| | |
3556 // | | RouteCreate | |
3557 // | |--------------------------->|
3558 // | | RouteResponse| |
3559 // | |<---------------------------|
3561 // | |------------->| |
3563 // | |<-------------| |
3564 // | RESTNotif1 | | |
3565 // |<----------------| | |
3568 //-----------------------------------------------------------------------------
3569 func TestRESTSubReqRetransmissionV6(t *testing.T) {
3571 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3572 Counter{cRestSubReqFromXapp, 3},
3573 Counter{cDuplicateE2SubReq, 1},
3574 Counter{cRestSubRespToXapp, 3},
3575 Counter{cSubReqToE2, 3},
3576 Counter{cSubRespFromE2, 3},
3577 Counter{cRestSubNotifToXapp, 4},
3578 Counter{cRestSubDelReqFromXapp, 2},
3579 Counter{cSubDelReqToE2, 3},
3580 Counter{cSubDelRespFromE2, 3},
3581 Counter{cRestSubDelRespToXapp, 2},
3584 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3586 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3588 mainCtrl.WaitOngoingRequestMapEmpty()
3590 // Send modified requst, this time with e2 subscriptions.
3591 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3592 params2.SetSubscriptionID(&restSubId)
3594 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3595 xappConn1.ExpectAnyNotification(t)
3596 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3597 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3599 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3600 assert.Equal(t, e2SubsId, e2SubsId1)
3602 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3604 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3605 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3606 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3607 assert.NotEqual(t, e2SubsId2, 0)
3609 mainCtrl.WaitOngoingRequestMapEmpty()
3611 // Delete both e2 subscriptions
3612 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3613 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3614 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3616 waitSubsCleanup(t, e2SubsId, 10)
3618 // Resend the original request, we shall find it's previous md5sum/restsubs
3619 // but the restsubscription has been already removed. This shall trigger a
3621 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
3623 mainCtrl.WaitOngoingRequestMapEmpty()
3625 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3627 waitSubsCleanup(t, e2SubsId, 10)
3628 mainCtrl.VerifyCounterValues(t)
3629 mainCtrl.VerifyAllClean(t)
3632 //-----------------------------------------------------------------------------
3633 // TestRESTSubDelReqRetransmission
3636 // +-------+ +---------+ +---------+
3637 // | xapp | | submgr | | e2term |
3638 // +-------+ +---------+ +---------+
3641 // |---------------->| |
3643 // | RESTSubResp | |
3644 // |<----------------| |
3646 // | |------------->|
3648 // | |<-------------|
3650 // |<----------------| |
3652 // | RESTSubDelReq | |
3653 // |---------------->| |
3654 // | RESTSubDelResp | |
3655 // |<----------------| |
3657 // | |------------->|
3658 // | RESTSubDelReq | |
3659 // |---------------->| |
3660 // | RESTSubDelResp | |
3661 // |<----------------| |
3663 // | |<-------------|
3666 //-----------------------------------------------------------------------------
3668 func TestRESTSubDelReqRetransmission(t *testing.T) {
3670 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3671 Counter{cRestSubReqFromXapp, 1},
3672 Counter{cRestSubRespToXapp, 1},
3673 Counter{cSubReqToE2, 1},
3674 Counter{cSubRespFromE2, 1},
3675 Counter{cRestSubNotifToXapp, 1},
3676 Counter{cRestSubDelReqFromXapp, 2},
3677 Counter{cSubDelReqToE2, 1},
3678 Counter{cSubDelRespFromE2, 1},
3679 Counter{cRestSubDelRespToXapp, 2},
3682 var params *teststube2ap.RESTSubsReqParams = nil
3685 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3687 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3690 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3691 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3694 seqBef := mainCtrl.get_msgcounter(t)
3695 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3696 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
3699 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3701 waitSubsCleanup(t, e2SubsId, 10)
3702 mainCtrl.VerifyCounterValues(t)
3703 mainCtrl.VerifyAllClean(t)
3706 //-----------------------------------------------------------------------------
3707 // TestRESTSubReqDelReq
3710 // +-------+ +---------+ +---------+
3711 // | xapp | | submgr | | e2term |
3712 // +-------+ +---------+ +---------+
3715 // |---------------->| |
3717 // | RESTSubResp | |
3718 // |<----------------| |
3720 // | |------------->|
3721 // | RESTSubDelReq | |
3722 // |---------------->| |
3723 // | RESTSubDelResp | |
3725 // |<----------------| |
3727 // | |<-------------|
3729 // |<----------------| |
3731 // | [SUBS DELETE] |
3734 //-----------------------------------------------------------------------------
3735 func TestRESTSubReqDelReq(t *testing.T) {
3737 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3738 Counter{cRestSubReqFromXapp, 1},
3739 Counter{cRestSubRespToXapp, 1},
3740 Counter{cSubReqToE2, 1},
3741 Counter{cSubRespFromE2, 1},
3742 Counter{cRestSubNotifToXapp, 1},
3743 Counter{cRestSubDelReqFromXapp, 2},
3744 Counter{cRestSubDelFailToXapp, 1},
3745 Counter{cSubDelReqToE2, 1},
3746 Counter{cSubDelRespFromE2, 1},
3747 Counter{cRestSubDelRespToXapp, 1},
3750 const subReqCount int = 1
3753 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3754 restSubId := xappConn1.SendRESTSubsReq(t, params)
3756 // Del. This will fail as processing of the subscription
3757 // is still ongoing in submgr. Deletion is not allowed before
3758 // subscription creation has been completed.
3759 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3760 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3761 xappConn1.ExpectRESTNotification(t, restSubId)
3762 e2termConn1.SendSubsResp(t, crereq, cremsg)
3763 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3766 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3768 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3769 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3771 // Wait that subs is cleaned
3772 waitSubsCleanup(t, e2SubsId, 10)
3773 mainCtrl.VerifyCounterValues(t)
3774 mainCtrl.VerifyAllClean(t)
3777 //-----------------------------------------------------------------------------
3778 // TestRESTSubReqAndSubDelOkTwoParallel
3781 // +-------+ +-------+ +---------+ +---------+
3782 // | xapp2 | | xapp1 | | submgr | | e2term |
3783 // +-------+ +-------+ +---------+ +---------+
3785 // | | RESTSubReq1 | |
3786 // | |------------->| |
3787 // | | RESTSubResp1 | |
3788 // | |<-------------| |
3791 // | | |------------->|
3793 // | RESTSubReq2 | |
3794 // |------------------------>| |
3795 // | RESTSubResp2 | |
3796 // |<------------------------| |
3799 // | | |------------->|
3802 // | | |<-------------|
3803 // | | RESTNotif1 | |
3804 // | |<-------------| |
3807 // | | |<-------------|
3809 // |<------------------------| |
3811 // | | [SUBS 1 DELETE] |
3813 // | | [SUBS 2 DELETE] |
3816 //-----------------------------------------------------------------------------
3818 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
3820 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3821 Counter{cRestSubReqFromXapp, 2},
3822 Counter{cRestSubRespToXapp, 2},
3823 Counter{cSubReqToE2, 2},
3824 Counter{cSubRespFromE2, 2},
3825 Counter{cRestSubNotifToXapp, 2},
3826 Counter{cRestSubDelReqFromXapp, 2},
3827 Counter{cSubDelReqToE2, 2},
3828 Counter{cSubDelRespFromE2, 2},
3829 Counter{cRestSubDelRespToXapp, 2},
3833 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3834 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3835 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3838 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3839 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3840 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3842 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3843 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3845 //XappConn1 receives both of the responses
3846 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3849 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3851 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3853 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3854 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3855 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3856 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3859 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3861 deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
3863 //Wait that subs is cleaned
3864 mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
3865 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
3867 mainCtrl.VerifyCounterValues(t)
3868 mainCtrl.VerifyAllClean(t)
3871 //-----------------------------------------------------------------------------
3872 // TestRESTSameSubsDiffRan
3873 // Same subscription to different RANs
3876 // +-------+ +---------+ +---------+
3877 // | xapp | | submgr | | e2term |
3878 // +-------+ +---------+ +---------+
3880 // | RESTSubReq(r1) | |
3881 // |---------------->| |
3882 // | RESTSubResp(r1) | |
3883 // |<----------------| |
3886 // | |------------->|
3888 // | | SubResp(r1) |
3889 // | |<-------------|
3891 // | RESTNotif(r1) | |
3892 // |<----------------| |
3894 // | RESTSubReq(r2) | |
3895 // |---------------->| |
3897 // | RESTSubResp(r2) | |
3898 // |<----------------| |
3900 // | |------------->|
3902 // | | SubResp(r2) |
3903 // | |<-------------|
3905 // | RESTNotif(r2) | |
3906 // |<----------------| |
3908 // | [SUBS r1 DELETE] |
3910 // | [SUBS r2 DELETE] |
3913 //-----------------------------------------------------------------------------
3915 func TestRESTSameSubsDiffRan(t *testing.T) {
3917 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3918 Counter{cRestSubReqFromXapp, 2},
3919 Counter{cRestSubRespToXapp, 2},
3920 Counter{cSubReqToE2, 2},
3921 Counter{cSubRespFromE2, 2},
3922 Counter{cRestSubNotifToXapp, 2},
3923 Counter{cRestSubDelReqFromXapp, 2},
3924 Counter{cSubDelReqToE2, 2},
3925 Counter{cSubDelRespFromE2, 2},
3926 Counter{cRestSubDelRespToXapp, 2},
3929 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3930 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3931 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3933 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3934 params.SetMeid("RAN_NAME_2")
3935 restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
3936 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3939 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3941 deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
3943 //Wait that subs is cleaned
3944 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3945 waitSubsCleanup(t, e2SubsId2, 10)
3947 mainCtrl.VerifyCounterValues(t)
3948 mainCtrl.VerifyAllClean(t)
3951 //-----------------------------------------------------------------------------
3952 // TestRESTSubReqRetryInSubmgr
3955 // +-------+ +---------+ +---------+
3956 // | xapp | | submgr | | e2term |
3957 // +-------+ +---------+ +---------+
3960 // |---------------->| |
3961 // | RESTSubResp | |
3962 // |<----------------| |
3967 // | |------------->|
3969 // | |<-------------|
3972 // |<----------------| |
3974 // | [SUBS DELETE] |
3977 //-----------------------------------------------------------------------------
3979 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
3981 // Init counter check
3982 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3983 Counter{cRestSubReqFromXapp, 1},
3984 Counter{cRestSubRespToXapp, 1},
3985 Counter{cSubReqToE2, 1},
3986 Counter{cSubReqTimerExpiry, 1},
3987 Counter{cSubReReqToE2, 1},
3988 Counter{cSubRespFromE2, 1},
3989 Counter{cRestSubNotifToXapp, 1},
3990 Counter{cRestSubDelReqFromXapp, 1},
3991 Counter{cSubDelReqToE2, 1},
3992 Counter{cSubDelRespFromE2, 1},
3993 Counter{cRestSubDelRespToXapp, 1},
3996 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3997 restSubId := xappConn1.SendRESTSubsReq(t, params)
3999 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
4001 // Catch the first message and ignore it
4002 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4003 xapp.Logger.Debug("Ignore REST subscriber request for subscriber : %v", restSubId)
4005 // The second request is being handled normally
4006 crereq, cremsg = e2termConn1.RecvSubsReq(t)
4007 xappConn1.ExpectRESTNotification(t, restSubId)
4008 e2termConn1.SendSubsResp(t, crereq, cremsg)
4009 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4011 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4014 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
4016 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
4017 //Wait that subs is cleaned
4018 waitSubsCleanup(t, e2SubsId, 10)
4020 mainCtrl.VerifyCounterValues(t)
4021 mainCtrl.VerifyAllClean(t)
4024 //-----------------------------------------------------------------------------
4025 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
4028 // +-------+ +---------+ +---------+
4029 // | xapp | | submgr | | e2term |
4030 // +-------+ +---------+ +---------+
4033 // |---------------->| |
4035 // | RESTSubResp | |
4036 // |<----------------| |
4038 // | |------------->|
4042 // | |------------->|
4045 // | |------------->|
4049 // | |------------->|
4053 // | |<-------------|
4056 // |<----------------| |
4058 // | [SUBS DELETE] |
4061 //-----------------------------------------------------------------------------
4063 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
4065 // Init counter check
4066 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4067 Counter{cRestSubReqFromXapp, 1},
4068 Counter{cRestSubRespToXapp, 1},
4069 Counter{cSubReqToE2, 1},
4070 Counter{cSubReReqToE2, 1},
4071 Counter{cSubReqTimerExpiry, 2},
4072 Counter{cRestSubFailNotifToXapp, 1},
4073 Counter{cSubDelReqToE2, 1},
4074 Counter{cSubDelRespFromE2, 1},
4075 Counter{cRestSubDelReqFromXapp, 1},
4076 Counter{cRestSubDelRespToXapp, 1},
4079 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4080 restSubId := xappConn1.SendRESTSubsReq(t, params)
4081 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
4083 e2termConn1.RecvSubsReq(t)
4084 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
4086 e2termConn1.RecvSubsReq(t)
4087 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
4089 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4090 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
4091 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4092 xappConn1.WaitRESTNotification(t, restSubId)
4094 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4096 // Wait that subs is cleaned
4097 waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
4098 mainCtrl.VerifyCounterValues(t)
4099 mainCtrl.VerifyAllClean(t)
4102 //-----------------------------------------------------------------------------
4103 // TestREST2eTermNotRespondingToSubReq
4106 // +-------+ +---------+ +---------+
4107 // | xapp | | submgr | | e2term |
4108 // +-------+ +---------+ +---------+
4111 // |---------------->| |
4112 // | RESTSubResp | |
4113 // |<----------------| |
4115 // | |------------->|
4118 // | |------------->|
4121 // | |------------->|
4124 // | |------------->|
4125 // | RESTNotif(Unsuccessful) |
4126 // |<----------------| |
4128 // | RESTSubDelReq | |
4129 // |---------------->| |
4130 // | RESTSubDelResp | |
4131 // |<----------------| |
4134 //-----------------------------------------------------------------------------
4136 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
4138 // Init counter check
4139 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4140 Counter{cRestSubReqFromXapp, 1},
4141 Counter{cRestSubRespToXapp, 1},
4142 Counter{cSubReqToE2, 1},
4143 Counter{cSubReReqToE2, 1},
4144 Counter{cSubReqTimerExpiry, 2},
4145 Counter{cSubDelReReqToE2, 1},
4146 Counter{cRestSubFailNotifToXapp, 1},
4147 Counter{cSubDelReqToE2, 1},
4148 Counter{cSubDelReqTimerExpiry, 2},
4149 Counter{cRestSubDelReqFromXapp, 1},
4150 Counter{cRestSubDelRespToXapp, 1},
4153 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4154 restSubId := xappConn1.SendRESTSubsReq(t, params)
4155 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
4157 e2termConn1.RecvSubsReq(t)
4158 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
4160 e2termConn1.RecvSubsReq(t)
4161 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
4163 e2termConn1.RecvSubsDelReq(t)
4164 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
4166 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
4167 e2termConn1.RecvSubsDelReq(t)
4168 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
4170 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4172 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4174 waitSubsCleanup(t, e2SubsId, 10)
4175 mainCtrl.VerifyCounterValues(t)
4176 mainCtrl.VerifyAllClean(t)
4179 //-----------------------------------------------------------------------------
4180 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
4183 // +-------+ +---------+ +---------+
4184 // | xapp | | submgr | | e2term |
4185 // +-------+ +---------+ +---------+
4188 // |---------------->| |
4190 // | RESTSubResp | |
4191 // |<----------------| |
4193 // | |------------->|
4197 // | |------------->|
4200 // | |------------->|
4204 // | |------------->|
4208 // | |<-------------|
4211 // |<----------------| |
4213 // | [SUBS DELETE] |
4216 //-----------------------------------------------------------------------------
4217 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
4219 // Init counter check
4220 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4221 Counter{cRestSubReqFromXapp, 1},
4222 Counter{cRestSubRespToXapp, 1},
4223 Counter{cSubReqToE2, 1},
4224 Counter{cSubReReqToE2, 1},
4225 Counter{cSubReqTimerExpiry, 2},
4226 Counter{cRestSubFailNotifToXapp, 1},
4227 Counter{cSubDelReqToE2, 1},
4228 Counter{cSubDelReReqToE2, 1},
4229 Counter{cSubDelReqTimerExpiry, 2},
4230 Counter{cRestSubDelReqFromXapp, 1},
4231 Counter{cRestSubDelRespToXapp, 1},
4234 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4235 restSubId := xappConn1.SendRESTSubsReq(t, params)
4236 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
4238 e2termConn1.RecvSubsReq(t)
4239 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
4241 e2termConn1.RecvSubsReq(t)
4242 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
4244 e2termConn1.RecvSubsDelReq(t)
4245 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
4247 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
4248 e2termConn1.RecvSubsDelReq(t)
4249 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
4251 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4253 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4255 waitSubsCleanup(t, e2SubsId, 10)
4256 mainCtrl.VerifyCounterValues(t)
4257 mainCtrl.VerifyAllClean(t)
4260 //-----------------------------------------------------------------------------
4261 // TestRESTSubReqSubFailRespInSubmgr
4264 // +-------+ +---------+ +---------+
4265 // | xapp | | submgr | | e2term |
4266 // +-------+ +---------+ +---------+
4269 // |---------------->| |
4271 // | RESTSubResp | |
4272 // |<----------------| |
4274 // | |------------->|
4277 // | |<-------------|
4281 // |<----------------| |
4283 // | [SUBS DELETE] |
4286 //-----------------------------------------------------------------------------
4288 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
4290 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4291 Counter{cRestSubReqFromXapp, 1},
4292 Counter{cRestSubRespToXapp, 1},
4293 Counter{cSubReqToE2, 1},
4294 Counter{cSubFailFromE2, 1},
4295 Counter{cRestSubFailNotifToXapp, 1},
4296 Counter{cRestSubDelReqFromXapp, 1},
4297 Counter{cRestSubDelRespToXapp, 1},
4300 const subReqCount int = 1
4301 const e2Timeout int64 = 2
4302 const e2RetryCount int64 = 1
4303 const routingNeeded bool = true
4305 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4306 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4307 restSubId := xappConn1.SendRESTSubsReq(t, params)
4309 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4310 fparams1 := &teststube2ap.E2StubSubsFailParams{}
4311 fparams1.Set(crereq1)
4312 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
4313 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
4315 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4316 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
4318 // REST subscription sill there to be deleted
4319 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4321 // Wait that subs is cleaned
4322 waitSubsCleanup(t, e2SubsId, 10)
4324 mainCtrl.VerifyCounterValues(t)
4325 mainCtrl.VerifyAllClean(t)
4328 //-----------------------------------------------------------------------------
4329 // TestRESTSubDelReqRetryInSubmgr
4332 // +-------+ +---------+ +---------+
4333 // | xapp | | submgr | | e2term |
4334 // +-------+ +---------+ +---------+
4336 // | [SUBS CREATE] |
4339 // | RESTSubDelReq | |
4340 // |---------------->| |
4342 // | RESTSubDelResp | |
4343 // |<----------------| |
4345 // | |------------->|
4348 // | |------------->|
4351 // | |<-------------|
4354 //-----------------------------------------------------------------------------
4355 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
4357 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4358 Counter{cRestSubReqFromXapp, 1},
4359 Counter{cRestSubRespToXapp, 1},
4360 Counter{cSubReqToE2, 1},
4361 Counter{cSubRespFromE2, 1},
4362 Counter{cRestSubNotifToXapp, 1},
4363 Counter{cRestSubDelReqFromXapp, 1},
4364 Counter{cSubDelReqToE2, 1},
4365 Counter{cSubDelReqTimerExpiry, 1},
4366 Counter{cSubDelReReqToE2, 1},
4367 Counter{cSubDelRespFromE2, 1},
4368 Counter{cRestSubDelRespToXapp, 1},
4371 var params *teststube2ap.RESTSubsReqParams = nil
4372 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4375 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4377 // E2t: Receive 1st SubsDelReq
4378 e2termConn1.RecvSubsDelReq(t)
4380 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4381 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4382 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4384 //Wait that subs is cleaned
4385 waitSubsCleanup(t, e2SubsId, 10)
4387 mainCtrl.VerifyCounterValues(t)
4388 mainCtrl.VerifyAllClean(t)
4391 //-----------------------------------------------------------------------------
4392 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
4395 // +-------+ +---------+ +---------+
4396 // | xapp | | submgr | | e2term |
4397 // +-------+ +---------+ +---------+
4399 // | [SUBS CREATE] |
4402 // | RESTSubDelReq | |
4403 // |---------------->| |
4405 // | RESTSubDelResp | |
4406 // |<----------------| |
4408 // | |------------->|
4411 // | |------------->|
4415 //-----------------------------------------------------------------------------
4417 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
4419 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4420 Counter{cRestSubReqFromXapp, 1},
4421 Counter{cRestSubRespToXapp, 1},
4422 Counter{cSubReqToE2, 1},
4423 Counter{cSubRespFromE2, 1},
4424 Counter{cRestSubNotifToXapp, 1},
4425 Counter{cRestSubDelReqFromXapp, 1},
4426 Counter{cSubDelReqToE2, 1},
4427 Counter{cSubDelReqTimerExpiry, 1},
4428 Counter{cSubDelReReqToE2, 1},
4429 Counter{cSubDelRespFromE2, 1},
4430 Counter{cRestSubDelRespToXapp, 1},
4434 var params *teststube2ap.RESTSubsReqParams = nil
4435 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4438 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4440 // E2t: Receive 1st SubsDelReq
4441 e2termConn1.RecvSubsDelReq(t)
4443 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4444 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4445 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4447 //Wait that subs is cleaned
4448 waitSubsCleanup(t, e2SubsId, 10)
4450 mainCtrl.VerifyCounterValues(t)
4451 mainCtrl.VerifyAllClean(t)
4454 //-----------------------------------------------------------------------------
4455 // TestRESTSubDelReqSubDelFailRespInSubmgr
4458 // +-------+ +---------+ +---------+
4459 // | xapp | | submgr | | e2term |
4460 // +-------+ +---------+ +---------+
4462 // | [SUBS CREATE] |
4465 // | RESTSubDelReq | |
4466 // |---------------->| |
4468 // | RESTSubDelResp | |
4469 // |<----------------| |
4471 // | |------------->|
4474 // | |<-------------|
4477 //-----------------------------------------------------------------------------
4479 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
4481 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4482 Counter{cRestSubReqFromXapp, 1},
4483 Counter{cRestSubRespToXapp, 1},
4484 Counter{cSubReqToE2, 1},
4485 Counter{cSubRespFromE2, 1},
4486 Counter{cRestSubNotifToXapp, 1},
4487 Counter{cRestSubDelReqFromXapp, 1},
4488 Counter{cSubDelReqToE2, 1},
4489 Counter{cSubDelFailFromE2, 1},
4490 Counter{cRestSubDelRespToXapp, 1},
4494 var params *teststube2ap.RESTSubsReqParams = nil
4495 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4498 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4500 // E2t: Send receive SubsDelReq and send SubsDelFail
4501 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4502 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
4504 //Wait that subs is cleaned
4505 waitSubsCleanup(t, e2SubsId, 10)
4507 mainCtrl.VerifyCounterValues(t)
4508 mainCtrl.VerifyAllClean(t)
4511 //-----------------------------------------------------------------------------
4512 // TestRESTSubReqAndSubDelOkSameAction
4515 // +-------+ +-------+ +---------+ +---------+
4516 // | xapp2 | | xapp1 | | submgr | | e2term |
4517 // +-------+ +-------+ +---------+ +---------+
4519 // | | RESTSubReq1 | |
4520 // | |---------------->| |
4522 // | | RESTSubResp1 | |
4523 // | |<----------------| |
4526 // | | |------------->|
4528 // | | |<-------------|
4529 // | | RESTNotif1 | |
4530 // | |<----------------| |
4532 // | RESTSubReq2 | |
4533 // |------------------------------>| |
4535 // | RESTSubResp2 | |
4536 // |<------------------------------| |
4538 // | | RESTNotif2 | |
4539 // |<------------------------------| |
4541 // | | RESTSubDelReq1 | |
4542 // | |---------------->| |
4544 // | | RESTSubDelResp1 | |
4545 // | |<----------------| |
4547 // | RESTSubDelReq2 | |
4548 // |------------------------------>| |
4550 // | RESTSubDelResp2 | |
4551 // |<------------------------------| |
4553 // | | | SubDelReq2 |
4554 // | | |------------->|
4556 // | | | SubDelResp2 |
4557 // | | |<-------------|
4560 //-----------------------------------------------------------------------------
4562 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
4564 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4565 Counter{cRestSubReqFromXapp, 2},
4566 Counter{cRestSubRespToXapp, 2},
4567 Counter{cSubReqToE2, 1},
4568 Counter{cSubRespFromE2, 1},
4569 Counter{cRestSubNotifToXapp, 2},
4570 Counter{cMergedSubscriptions, 1},
4571 Counter{cUnmergedSubscriptions, 1},
4572 Counter{cRestSubDelReqFromXapp, 2},
4573 Counter{cSubDelReqToE2, 1},
4574 Counter{cSubDelRespFromE2, 1},
4575 Counter{cRestSubDelRespToXapp, 2},
4579 var params *teststube2ap.RESTSubsReqParams = nil
4582 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4583 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4586 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4587 params.SetMeid("RAN_NAME_1")
4589 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4590 xappConn2.ExpectAnyNotification(t)
4591 waiter := rtmgrHttp.AllocNextSleep(10, true)
4592 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4593 waiter.WaitResult(t)
4594 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
4595 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
4596 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
4598 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
4601 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4604 deleteXapp2Subscription(t, &restSubId2)
4606 //Wait that subs is cleaned
4607 waitSubsCleanup(t, e2SubsId2, 10)
4608 mainCtrl.VerifyCounterValues(t)
4609 mainCtrl.VerifyAllClean(t)
4612 //-----------------------------------------------------------------------------
4613 // TestSubReqAndSubDelOkSameActionParallel
4616 // +-------+ +-------+ +---------+ +---------+
4617 // | xapp2 | | xapp1 | | submgr | | e2term |
4618 // +-------+ +-------+ +---------+ +---------+
4623 // | |------------->| |
4626 // | | |------------->|
4628 // |--------------------------->| |
4630 // | | |<-------------|
4632 // | |<-------------| |
4634 // | | |------------->|
4637 // | | |<-------------|
4639 // |<---------------------------| |
4641 // | | SubDelReq 1 | |
4642 // | |------------->| |
4644 // | | SubDelResp 1 | |
4645 // | |<-------------| |
4647 // | SubDelReq 2 | |
4648 // |--------------------------->| |
4650 // | | | SubDelReq 2 |
4651 // | | |------------->|
4653 // | | | SubDelReq 2 |
4654 // | | |------------->|
4656 // | SubDelResp 2 | |
4657 // |<---------------------------| |
4659 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
4661 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4662 Counter{cRestSubReqFromXapp, 2},
4663 Counter{cRestSubRespToXapp, 2},
4664 Counter{cSubReqToE2, 2},
4665 Counter{cSubRespFromE2, 2},
4666 Counter{cRestSubNotifToXapp, 2},
4667 Counter{cRestSubDelReqFromXapp, 2},
4668 Counter{cSubDelReqToE2, 2},
4669 Counter{cSubDelRespFromE2, 2},
4670 Counter{cRestSubDelRespToXapp, 2},
4673 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4674 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4675 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4677 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4678 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4680 xappConn1.ExpectRESTNotification(t, restSubId1)
4681 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4682 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4684 xappConn2.ExpectRESTNotification(t, restSubId2)
4685 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
4686 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
4687 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4690 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4691 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4692 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4693 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4696 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4697 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
4698 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
4700 waitSubsCleanup(t, e2SubsId2, 10)
4701 mainCtrl.VerifyCounterValues(t)
4702 mainCtrl.VerifyAllClean(t)
4705 //-----------------------------------------------------------------------------
4706 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
4709 // +-------+ +-------+ +---------+ +---------+
4710 // | xapp2 | | xapp1 | | submgr | | e2term |
4711 // +-------+ +-------+ +---------+ +---------+
4715 // | | RESTSubReq1 | |
4716 // | |---------------->| |
4718 // | | RESTSubResp1 | |
4719 // | |<----------------| |
4721 // | | |------------->|
4722 // | RESTSubReq2 | |
4723 // |------------------------------>| |
4725 // | RESTSubResp2 | |
4726 // |<------------------------------| |
4728 // | | |------------->|
4731 // | | | SubDelReq |
4732 // | | |------------->|
4734 // | | | SubDelResp |
4735 // | | |<-------------|
4736 // | | RESTNotif1 | |
4737 // | | unsuccess | |
4738 // | |<----------------| |
4740 // | | unsuccess | |
4741 // |<------------------------------| |
4743 // | | RESTSubDelReq1 | |
4744 // | |---------------->| |
4746 // | | RESTSubDelResp1 | |
4747 // | |<----------------| |
4749 // | RESTSubDelReq2 | |
4750 // |------------------------------>| |
4752 // | RESTSubDelResp2 | |
4753 // |<------------------------------| |
4755 //-----------------------------------------------------------------------------
4757 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
4759 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4760 Counter{cRestSubReqFromXapp, 2},
4761 Counter{cMergedSubscriptions, 1},
4762 Counter{cRestSubRespToXapp, 2},
4763 Counter{cSubReqToE2, 1},
4764 Counter{cSubReqTimerExpiry, 2},
4765 Counter{cSubReReqToE2, 1},
4766 Counter{cRestSubFailNotifToXapp, 2},
4767 Counter{cUnmergedSubscriptions, 1},
4768 Counter{cRestSubDelReqFromXapp, 2},
4769 Counter{cSubDelReqToE2, 1},
4770 Counter{cSubDelRespFromE2, 1},
4771 Counter{cRestSubDelRespToXapp, 2},
4773 const subReqCount int = 1
4776 params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4777 restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
4778 crereq1, _ := e2termConn1.RecvSubsReq(t)
4781 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4782 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4783 params2.SetMeid("RAN_NAME_1")
4784 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4785 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4787 //Req1 (retransmitted)
4788 e2termConn1.RecvSubsReq(t)
4790 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4792 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4793 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4795 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4796 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4797 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4798 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4801 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4804 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4806 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
4808 //Wait that subs is cleaned
4809 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4810 mainCtrl.VerifyCounterValues(t)
4811 mainCtrl.VerifyAllClean(t)
4814 //-----------------------------------------------------------------------------
4815 // TestRESTSubReqAndSubDelNokSameActionParallel
4818 // +-------+ +-------+ +---------+ +---------+
4819 // | xapp2 | | xapp1 | | submgr | | e2term |
4820 // +-------+ +-------+ +---------+ +---------+
4824 // | | RESTSubReq1 | |
4825 // | |---------------->| |
4827 // | | RESTSubResp1 | |
4828 // | |<----------------| |
4830 // | | |------------->|
4831 // | RESTSubReq2 | |
4832 // |------------------------------>| |
4834 // | RESTSubDelResp2 | |
4835 // |<------------------------------| |
4837 // | | |<-------------|
4839 // | | RESTNotif1 | |
4840 // | | unsuccess | |
4841 // | |<----------------| |
4843 // | | unsuccess | |
4844 // |<------------------------------| |
4846 // | | RESTSubDelReq1 | | There is no need for xApp to send delete for failed subscriptions but some xApp might do so.
4847 // | |---------------->| |
4849 // | | RESTSubDelResp1 | |
4850 // | |<----------------| |
4852 // | RESTSubDelReq2 | |
4853 // |------------------------------>| |
4855 // | RESTSubDelResp2 | |
4856 // |<------------------------------| |
4858 //-----------------------------------------------------------------------------
4860 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
4862 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4863 Counter{cRestSubReqFromXapp, 2},
4864 Counter{cMergedSubscriptions, 1},
4865 Counter{cRestSubRespToXapp, 2},
4866 Counter{cSubReqToE2, 1},
4867 Counter{cSubFailFromE2, 1},
4868 Counter{cRestSubFailNotifToXapp, 2},
4869 Counter{cUnmergedSubscriptions, 1},
4870 Counter{cRestSubDelReqFromXapp, 2},
4871 Counter{cRestSubDelRespToXapp, 2},
4874 const subReqCount int = 1
4877 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4878 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4879 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4882 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4883 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4884 params2.SetMeid("RAN_NAME_1")
4885 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4886 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4888 // E2t: send SubsFail (first)
4889 fparams1 := &teststube2ap.E2StubSubsFailParams{}
4890 fparams1.Set(crereq1)
4891 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
4893 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4894 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4895 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4896 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4897 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4900 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4903 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4905 //Wait that subs is cleaned
4906 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4907 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
4908 mainCtrl.VerifyCounterValues(t)
4909 mainCtrl.VerifyAllClean(t)
4912 //-----------------------------------------------------------------------------
4913 // TestRESTSubReqPolicyAndSubDelOk
4916 // +-------+ +---------+ +---------+
4917 // | xapp | | submgr | | e2term |
4918 // +-------+ +---------+ +---------+
4921 // |--------------->| |
4922 // | RESTSubResp | |
4923 // |<---------------| |
4926 // | |------------->|
4929 // | |<-------------|
4932 // |<---------------| |
4935 // | RESTSubDelReq | |
4936 // |--------------->| |
4937 // | RESTSubDelResp | |
4938 // |<---------------| |
4941 // | |------------->|
4944 // | |<-------------|
4947 //-----------------------------------------------------------------------------
4949 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
4951 // Init counter check
4952 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4953 Counter{cRestSubReqFromXapp, 1},
4954 Counter{cRestSubRespToXapp, 1},
4955 Counter{cSubReqToE2, 1},
4956 Counter{cSubRespFromE2, 1},
4957 Counter{cRestSubNotifToXapp, 1},
4958 Counter{cRestSubDelReqFromXapp, 1},
4959 Counter{cSubDelReqToE2, 1},
4960 Counter{cSubDelRespFromE2, 1},
4961 Counter{cRestSubDelRespToXapp, 1},
4964 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4965 restSubId := xappConn1.SendRESTSubsReq(t, params)
4966 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
4968 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4969 xappConn1.ExpectRESTNotification(t, restSubId)
4970 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4971 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4972 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
4974 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4975 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4976 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4978 // Wait that subs is cleaned
4979 waitSubsCleanup(t, e2SubsId, 10)
4980 mainCtrl.VerifyCounterValues(t)
4981 mainCtrl.VerifyAllClean(t)
4984 //-----------------------------------------------------------------------------
4985 // TestRESTSubReqPolicyChangeAndSubDelOk
4988 // +-------+ +---------+ +---------+
4989 // | xapp | | submgr | | e2term |
4990 // +-------+ +---------+ +---------+
4993 // |---------------->| |
4995 // | RESTSubResp | |
4996 // |<----------------| |
4998 // | |------------->|
5001 // | |<-------------|
5004 // |<----------------| |
5007 // |---------------->| |
5009 // | RESTSubResp | |
5010 // |<----------------| |
5012 // | |------------->|
5015 // | |<-------------|
5018 // |<----------------| |
5020 // | RESTSubDelReq | |
5021 // |---------------->| |
5024 // | |------------->|
5027 // | |<-------------|
5029 // | RESTSubDelResp | |
5030 // |<----------------| |
5032 //-----------------------------------------------------------------------------
5034 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
5036 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5037 Counter{cRestSubReqFromXapp, 2},
5038 Counter{cRestSubRespToXapp, 2},
5039 Counter{cSubReqToE2, 2},
5040 Counter{cSubRespFromE2, 2},
5041 Counter{cRestSubNotifToXapp, 2},
5042 Counter{cRestSubDelReqFromXapp, 1},
5043 Counter{cSubDelReqToE2, 1},
5044 Counter{cSubDelRespFromE2, 1},
5045 Counter{cRestSubDelRespToXapp, 1},
5048 const subReqCount int = 1
5049 const e2Timeout int64 = 1
5050 const e2RetryCount int64 = 0
5051 const routingNeeded bool = true
5054 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5055 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5056 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5059 // GetRESTSubsReqPolicyParams sets some counters on tc side.
5061 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5062 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5063 params.SetSubscriptionID(&restSubId)
5064 params.SetTimeToWait("w200ms")
5065 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
5068 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5070 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5071 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5073 // Wait that subs is cleaned
5074 waitSubsCleanup(t, e2SubsId, 10)
5075 mainCtrl.VerifyCounterValues(t)
5076 mainCtrl.VerifyAllClean(t)
5079 //-----------------------------------------------------------------------------
5080 // TestRESTSubReqPolicyChangeNOk
5083 // +-------+ +---------+ +---------+
5084 // | xapp | | submgr | | e2term |
5085 // +-------+ +---------+ +---------+
5088 // |---------------->| |
5090 // | RESTSubResp | |
5091 // |<----------------| |
5093 // | |------------->|
5096 // | |<-------------|
5099 // |<----------------| |
5102 // |---------------->| |
5104 // | RESTSubUpdateFail(400 Bad request)
5106 // | RESTSubDelReq | |
5107 // |---------------->| |
5110 // | |------------->|
5113 // | |<-------------|
5115 // | RESTSubDelResp | |
5116 // |<----------------| |
5118 //-----------------------------------------------------------------------------
5120 func TestRESTSubReqPolicyChangeNOk(t *testing.T) {
5122 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5123 Counter{cRestSubReqFromXapp, 2},
5124 Counter{cRestSubRespToXapp, 1},
5125 Counter{cSubReqToE2, 1},
5126 Counter{cSubRespFromE2, 1},
5127 Counter{cRestSubNotifToXapp, 1},
5128 Counter{cRestSubFailToXapp, 1},
5129 Counter{cRestSubDelReqFromXapp, 1},
5130 Counter{cSubDelReqToE2, 1},
5131 Counter{cSubDelRespFromE2, 1},
5132 Counter{cRestSubDelRespToXapp, 1},
5136 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5137 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5140 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5142 restSubIdUpd := strings.ToUpper(restSubId) // This makes RESTSubReq to fail
5143 params.SetSubscriptionID(&restSubIdUpd)
5144 params.SetTimeToWait("w200ms")
5146 restSubId2 := xappConn1.SendRESTSubsReq(t, params)
5147 assert.Equal(t, restSubId2, "")
5150 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5152 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5153 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5155 // Wait that subs is cleaned
5156 waitSubsCleanup(t, e2SubsId, 10)
5157 mainCtrl.VerifyCounterValues(t)
5158 mainCtrl.VerifyAllClean(t)
5161 //-----------------------------------------------------------------------------
5162 // TestRESTSubReqAndSubDelOkTwoE2termParallel
5165 // +-------+ +---------+ +---------+ +---------+
5166 // | xapp | | submgr | | e2term1 | | e2term2 |
5167 // +-------+ +---------+ +---------+ +---------+
5171 // | RESTSubReq1 | | |
5172 // |---------------->| | |
5174 // | RESTSubResp1 | | |
5175 // |<----------------| | |
5177 // | |------------->| |
5179 // | RESTSubReq2 | | |
5180 // |---------------->| | |
5182 // | RESTSubResp2 | | |
5183 // |<----------------| | |
5185 // | |---------------------------->|
5188 // | |<-------------| |
5189 // | RESTNotif1 | | |
5190 // |<----------------| | |
5192 // | |<----------------------------|
5193 // | RESTNotif2 | | |
5194 // |<----------------| | |
5196 // | [SUBS 1 DELETE] | |
5198 // | [SUBS 2 DELETE] | |
5201 //-----------------------------------------------------------------------------
5203 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
5205 // Init counter check
5206 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5207 Counter{cRestSubReqFromXapp, 2},
5208 Counter{cRestSubRespToXapp, 2},
5209 Counter{cSubReqToE2, 2},
5210 Counter{cSubRespFromE2, 2},
5211 Counter{cRestSubNotifToXapp, 2},
5212 Counter{cRestSubDelReqFromXapp, 2},
5213 Counter{cSubDelReqToE2, 2},
5214 Counter{cSubDelRespFromE2, 2},
5215 Counter{cRestSubDelRespToXapp, 2},
5218 const subReqCount int = 1
5221 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5222 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
5223 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
5226 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5227 params.SetMeid("RAN_NAME_11")
5228 // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
5229 // would not work as notification would not be received
5230 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5231 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
5234 xappConn1.ExpectRESTNotification(t, restSubId1)
5235 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
5236 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
5237 xapp.Logger.Debug("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
5240 xappConn2.ExpectRESTNotification(t, restSubId2)
5241 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
5242 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5243 xapp.Logger.Debug("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
5246 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5247 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
5248 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
5250 // Wait that subs is cleaned
5251 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
5254 xappConn1.SendRESTSubsDelReq(t, &restSubId2)
5255 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
5256 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
5258 // Wait that subs is cleaned
5259 waitSubsCleanup(t, e2SubsId2, 10)
5261 mainCtrl.VerifyCounterValues(t)
5262 mainCtrl.VerifyAllClean(t)
5265 //-----------------------------------------------------------------------------
5266 // TestRESTSubReqInsertAndSubDelOk
5269 // +-------+ +---------+ +---------+
5270 // | xapp | | submgr | | e2term |
5271 // +-------+ +---------+ +---------+
5274 // |---------------->| |
5276 // | RESTSubResp | |
5277 // |<----------------| |
5280 // | |------------->|
5283 // | |<-------------|
5285 // |<----------------| |
5288 // | RESTSubDelReq | |
5289 // |---------------->| |
5292 // | |------------->|
5295 // | |<-------------|
5297 // | RESTSubDelResp| |
5298 // |<----------------| |
5300 //-----------------------------------------------------------------------------
5302 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
5304 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5305 Counter{cRestSubReqFromXapp, 1},
5306 Counter{cRestSubRespToXapp, 1},
5307 Counter{cSubReqToE2, 1},
5308 Counter{cSubRespFromE2, 1},
5309 Counter{cRestSubNotifToXapp, 1},
5310 Counter{cRestSubDelReqFromXapp, 1},
5311 Counter{cSubDelReqToE2, 1},
5312 Counter{cSubDelRespFromE2, 1},
5313 Counter{cRestSubDelRespToXapp, 1},
5316 const subReqCount int = 1
5318 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5319 params.SetSubActionTypes("insert")
5322 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5325 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5327 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5328 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5330 // Wait that subs is cleaned
5331 waitSubsCleanup(t, e2SubsId, 10)
5332 mainCtrl.VerifyCounterValues(t)
5333 mainCtrl.VerifyAllClean(t)
5336 //-----------------------------------------------------------------------------
5337 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
5340 // +-------+ +---------+ +---------+
5341 // | xapp | | submgr | | e2term |
5342 // +-------+ +---------+ +---------+
5345 // |------------->| |
5347 // | RESTSubResp | |
5348 // |<-------------| |
5350 // | |------------->|
5355 // | Submgr restart |
5359 // | |------------->|
5362 // | |<-------------|
5366 // |<-------------| |
5368 // | RESTSubDelReq| |
5369 // |------------->| |
5371 // |RESTSubDelResp| |
5372 // |<-------------| |
5374 //-----------------------------------------------------------------------------
5376 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
5378 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5379 Counter{cRestSubReqFromXapp, 1},
5380 Counter{cRestSubRespToXapp, 1},
5381 Counter{cSubReqToE2, 1},
5382 Counter{cSubDelReqFromXapp, 1},
5383 Counter{cSubDelReqToE2, 1},
5384 Counter{cSubDelRespFromE2, 1},
5385 Counter{cRestSubDelReqFromXapp, 1},
5386 Counter{cRestSubDelRespToXapp, 1},
5389 const subReqCount int = 1
5391 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5394 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
5395 restSubId := xappConn1.SendRESTSubsReq(t, params)
5396 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5398 e2termConn1.RecvSubsReq(t)
5400 mainCtrl.SetResetTestFlag(t, false)
5402 mainCtrl.SimulateRestart(t)
5403 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5405 // Deleletion of uncompleted subscription
5406 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5407 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5410 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5412 xappConn1.TestMsgChanEmpty(t)
5413 e2termConn1.TestMsgChanEmpty(t)
5414 mainCtrl.wait_registry_empty(t, 10)
5416 mainCtrl.VerifyCounterValues(t)
5417 mainCtrl.VerifyAllClean(t)
5420 //-----------------------------------------------------------------------------
5421 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
5424 // +-------+ +---------+ +---------+
5425 // | xapp | | submgr | | e2term |
5426 // +-------+ +---------+ +---------+
5429 // |---------------->| |
5431 // | RESTSubResp | |
5432 // |<----------------| |
5434 // | |------------->|
5437 // | |<-------------|
5440 // |<----------------| |
5443 // | Submgr restart |
5445 // | RESTSubDelReq | |
5446 // |---------------->| |
5449 // | |------------->|
5452 // | |<-------------|
5454 // | RESTSubDelResp | |
5455 // |<----------------| |
5457 //-----------------------------------------------------------------------------
5459 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
5461 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5462 Counter{cRestSubReqFromXapp, 1},
5463 Counter{cRestSubRespToXapp, 1},
5464 Counter{cSubReqToE2, 1},
5465 Counter{cSubRespFromE2, 1},
5466 Counter{cRestSubNotifToXapp, 1},
5467 Counter{cRestSubDelReqFromXapp, 1},
5468 Counter{cSubDelReqToE2, 1},
5469 Counter{cSubDelRespFromE2, 1},
5470 Counter{cRestSubDelRespToXapp, 1},
5473 // Create subscription
5474 var params *teststube2ap.RESTSubsReqParams = nil
5475 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5476 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5478 // Check subscription
5479 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5481 mainCtrl.SimulateRestart(t)
5482 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5484 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5485 // That needs to be completed before successful subscription query is possible
5486 <-time.After(time.Second * 1)
5488 // Check subscription
5489 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5491 // Delete subscription
5492 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
5494 //Wait that subs is cleaned
5495 waitSubsCleanup(t, e2SubsId, 10)
5497 mainCtrl.VerifyCounterValues(t)
5498 mainCtrl.VerifyAllClean(t)
5501 //-----------------------------------------------------------------------------
5502 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
5505 // +-------+ +-------+ +---------+ +---------+
5506 // | xapp2 | | xapp1 | | submgr | | e2term |
5507 // +-------+ +-------+ +---------+ +---------+
5509 // | | RESTSubReq1 | |
5510 // | |---------------->| |
5512 // | | RESTSubResp1 | |
5513 // | |<----------------| |
5516 // | | |------------->|
5518 // | | |<-------------|
5519 // | | RESTNotif1 | |
5520 // | |<----------------| |
5522 // | RESTSubReq2 | |
5523 // |------------------------------>| |
5525 // | RESTSubResp2 | |
5526 // |<------------------------------| |
5528 // | | RESTNotif2 | |
5529 // |<------------------------------| |
5531 // | | Submgr restart |
5533 // | | RESTSubDelReq1 | |
5534 // | |---------------->| |
5536 // | | RESTSubDelResp1 | |
5537 // | |<----------------| |
5539 // | | Submgr restart |
5541 // | RESTSubDelReq2 | |
5542 // |------------------------------>| |
5544 // | RESTSubDelResp2 | |
5545 // |<------------------------------| |
5547 // | | | SubDelReq2 |
5548 // | | |------------->|
5550 // | | | SubDelResp2 |
5551 // | | |<-------------|
5554 //-----------------------------------------------------------------------------
5555 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
5557 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5558 Counter{cRestSubReqFromXapp, 2},
5559 Counter{cRestSubRespToXapp, 2},
5560 Counter{cSubReqToE2, 1},
5561 Counter{cSubRespFromE2, 1},
5562 Counter{cRestSubNotifToXapp, 2},
5563 Counter{cMergedSubscriptions, 1},
5564 Counter{cUnmergedSubscriptions, 1},
5565 Counter{cRestSubDelReqFromXapp, 2},
5566 Counter{cSubDelReqToE2, 1},
5567 Counter{cSubDelRespFromE2, 1},
5568 Counter{cRestSubDelRespToXapp, 2},
5571 // Create subscription 1
5572 var params *teststube2ap.RESTSubsReqParams = nil
5573 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5574 xapp.Logger.Debug("Send REST subscriber request for subscriber 1 : %v", restSubId1)
5576 // Create subscription 2 with same action
5577 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5578 params.SetMeid("RAN_NAME_1")
5579 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
5580 xappConn2.ExpectAnyNotification(t)
5581 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5582 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5583 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
5584 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
5586 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
5588 mainCtrl.SimulateRestart(t)
5589 xapp.Logger.Debug("mainCtrl.SimulateRestart done 1")
5591 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5592 // That needs to be completed before successful subscription delete is possible
5593 <-time.After(time.Second * 1)
5595 // Delete subscription 1, and wait until it has removed the first endpoint
5596 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5597 mainCtrl.WaitRESTSubscriptionDelete(restSubId1)
5598 // Above wait does not work correctly anymore as this delay makes this test case work
5600 mainCtrl.SimulateRestart(t)
5601 xapp.Logger.Debug("mainCtrl.SimulateRestart done 2")
5603 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5604 // That needs to be completed before successful subscription query is possible
5605 <-time.After(time.Second * 1)
5607 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
5609 // Delete subscription 2
5610 deleteXapp2Subscription(t, &restSubId2)
5612 //Wait that subs is cleaned
5613 waitSubsCleanup(t, e2SubsId2, 10)
5615 mainCtrl.VerifyCounterValues(t)
5616 mainCtrl.VerifyAllClean(t)
5619 //-----------------------------------------------------------------------------
5620 // TestRESTReportSubReqAndSubDelOk
5623 // +-------+ +---------+ +---------+
5624 // | xapp | | submgr | | e2term |
5625 // +-------+ +---------+ +---------+
5628 // |---------------->| |
5630 // | RESTSubResp | |
5631 // |<----------------| |
5634 // | |------------->|
5637 // | |<-------------|
5639 // |<----------------| |
5640 // | | SubReq | // Only one request sent in the teat case
5641 // | |------------->|
5644 // | |<-------------|
5646 // |<----------------| |
5650 // | RESTSubDelReq | |
5651 // |---------------->| |
5653 // | RESTSubDelResp| |
5654 // |<----------------| |
5656 // | |------------->|
5659 // | |<-------------|
5662 //-----------------------------------------------------------------------------
5664 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
5665 const subReqCount int = 1
5667 RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
5670 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5671 xapp.Logger.Debug("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
5673 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5674 Counter{cRestSubReqFromXapp, 1},
5675 Counter{cRestSubRespToXapp, 1},
5676 Counter{cSubReqToE2, uint64(subReqCount)},
5677 Counter{cSubRespFromE2, uint64(subReqCount)},
5678 Counter{cRestSubNotifToXapp, 1},
5679 Counter{cRestSubDelReqFromXapp, 1},
5680 Counter{cRestSubDelRespToXapp, 1},
5681 Counter{cSubDelReqToE2, uint64(subReqCount)},
5682 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5686 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5687 restSubId := xappConn1.SendRESTSubsReq(t, params)
5689 var e2SubsId []uint32
5690 for i := 0; i < subReqCount; i++ {
5691 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5692 xappConn1.ExpectRESTNotification(t, restSubId)
5694 e2termConn1.SendSubsResp(t, crereq, cremsg)
5695 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5696 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5697 e2SubsId = append(e2SubsId, instanceId)
5698 resp, _ := xapp.Subscription.QuerySubscriptions()
5699 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
5700 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
5701 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
5706 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5708 for i := 0; i < subReqCount; i++ {
5709 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5710 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5713 // Wait that subs is cleaned
5714 for i := 0; i < subReqCount; i++ {
5715 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5718 xappConn1.TestMsgChanEmpty(t)
5719 e2termConn1.TestMsgChanEmpty(t)
5720 mainCtrl.wait_registry_empty(t, 10)
5721 mainCtrl.VerifyAllClean(t)
5722 mainCtrl.VerifyCounterValues(t)
5725 //-----------------------------------------------------------------------------
5726 // TestRESTTwoPolicySubReqAndSubDelOk
5729 // +-------+ +---------+ +---------+
5730 // | xapp | | submgr | | e2term |
5731 // +-------+ +---------+ +---------+
5734 // |---------------->| |
5736 // | RESTSubResp | |
5737 // |<----------------| |
5740 // | |------------->|
5743 // | |<-------------|
5745 // |<----------------| |
5747 // | |------------->|
5750 // | |<-------------|
5752 // |<----------------| |
5754 // | RESTSubDelReq | |
5755 // |---------------->| |
5757 // | RESTSubDelResp| |
5758 // |<----------------| |
5760 // | |------------->|
5763 // | |<-------------|
5766 // | |------------->|
5769 // | |<-------------|
5772 //-----------------------------------------------------------------------------
5774 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
5776 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5777 Counter{cRestSubReqFromXapp, 1},
5778 Counter{cRestSubRespToXapp, 1},
5779 Counter{cSubReqToE2, 2},
5780 Counter{cSubRespFromE2, 2},
5781 Counter{cRestSubNotifToXapp, 2},
5782 Counter{cRestSubDelReqFromXapp, 1},
5783 Counter{cSubDelReqToE2, 2},
5784 Counter{cSubDelRespFromE2, 2},
5785 Counter{cRestSubDelRespToXapp, 1},
5788 const subReqCount int = 2
5791 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5792 restSubId := xappConn1.SendRESTSubsReq(t, params)
5793 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5795 assert.Equal(t, len(e2SubsIds), 2)
5798 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5799 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5801 xappConn1.TestMsgChanEmpty(t)
5802 e2termConn1.TestMsgChanEmpty(t)
5803 mainCtrl.wait_registry_empty(t, 10)
5805 mainCtrl.VerifyCounterValues(t)
5806 mainCtrl.VerifyAllClean(t)
5809 //-----------------------------------------------------------------------------
5810 // TestRESTPolicySubReqAndSubDelOk19E2Subs
5813 // +-------+ +---------+ +---------+
5814 // | xapp | | submgr | | e2term |
5815 // +-------+ +---------+ +---------+
5818 // |---------------->| |
5820 // | RESTSubResp | |
5821 // |<----------------| |
5824 // | |------------->|
5825 // | | | E2 subscription x 19
5827 // | |<-------------|
5829 // |<----------------| |
5831 // | RESTSubDelReq | |
5832 // |---------------->| |
5834 // | RESTSubDelResp| |
5835 // |<----------------| |
5836 // | | SubDelReq | ------
5837 // | |------------->|
5838 // | | | E2 subscription delete x 19
5840 // | |<-------------|
5844 //-----------------------------------------------------------------------------
5846 func TestRESTPolicySubReqAndSubDelOk19E2Subs(t *testing.T) {
5848 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5849 Counter{cRestSubReqFromXapp, 1},
5850 Counter{cRestSubRespToXapp, 1},
5851 Counter{cSubReqToE2, 19},
5852 Counter{cSubRespFromE2, 19},
5853 Counter{cRestSubNotifToXapp, 19},
5854 Counter{cRestSubDelReqFromXapp, 1},
5855 Counter{cSubDelReqToE2, 19},
5856 Counter{cSubDelRespFromE2, 19},
5857 Counter{cRestSubDelRespToXapp, 1},
5860 const subReqCount int = 19
5862 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5863 restSubId := xappConn1.SendRESTSubsReq(t, params)
5864 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5866 assert.Equal(t, len(e2SubsIds), 19)
5868 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5869 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5871 xappConn1.TestMsgChanEmpty(t)
5872 e2termConn1.TestMsgChanEmpty(t)
5873 mainCtrl.wait_registry_empty(t, 10)
5875 mainCtrl.VerifyCounterValues(t)
5876 mainCtrl.VerifyAllClean(t)
5879 //-----------------------------------------------------------------------------
5880 // TestRESTTwoPolicySubReqAndSubDelOk
5883 // +-------+ +---------+ +---------+
5884 // | xapp | | submgr | | e2term |
5885 // +-------+ +---------+ +---------+
5888 // |---------------->| |
5890 // | RESTSubResp | |
5891 // |<----------------| |
5894 // | |------------->|
5897 // | |<-------------|
5899 // |<----------------| |
5901 // | |------------->|
5904 // | |<-------------|
5906 // |<----------------| |
5908 // | RESTSubDelReq | |
5909 // |---------------->| |
5911 // | RESTSubDelResp| |
5912 // |<----------------| |
5914 // | |------------->|
5917 // | |<-------------|
5920 // | |------------->|
5923 // | |<-------------|
5926 //-----------------------------------------------------------------------------
5928 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
5932 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5933 Counter{cRestSubReqFromXapp, 1},
5934 Counter{cRestSubRespToXapp, 1},
5935 Counter{cSubReqToE2, uint64(subReqCount)},
5936 Counter{cSubRespFromE2, uint64(subReqCount)},
5937 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5938 Counter{cRestSubDelReqFromXapp, 1},
5939 Counter{cSubDelReqToE2, uint64(subReqCount)},
5940 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5941 Counter{cRestSubDelRespToXapp, 1},
5945 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5946 restSubId := xappConn1.SendRESTSubsReq(t, params)
5947 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5949 assert.Equal(t, len(e2SubsIds), subReqCount)
5952 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5953 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5955 xappConn1.TestMsgChanEmpty(t)
5956 e2termConn1.TestMsgChanEmpty(t)
5957 mainCtrl.wait_registry_empty(t, 10)
5959 mainCtrl.VerifyCounterValues(t)
5960 mainCtrl.VerifyAllClean(t)
5963 //-----------------------------------------------------------------------------
5964 // TestRESTTwoReportSubReqAndSubDelOkNoActParams
5967 // +-------+ +---------+ +---------+
5968 // | xapp | | submgr | | e2term |
5969 // +-------+ +---------+ +---------+
5972 // |---------------->| |
5974 // | RESTSubResp | |
5975 // |<----------------| |
5978 // | |------------->|
5981 // | |<-------------|
5983 // |<----------------| |
5985 // | |------------->|
5988 // | |<-------------|
5990 // |<----------------| |
5992 // | RESTSubDelReq | |
5993 // |---------------->| |
5995 // | RESTSubDelResp| |
5996 // |<----------------| |
5998 // | |------------->|
6001 // | |<-------------|
6004 // | |------------->|
6007 // | |<-------------|
6010 //-----------------------------------------------------------------------------
6012 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
6016 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6017 Counter{cRestSubReqFromXapp, 1},
6018 Counter{cRestSubRespToXapp, 1},
6019 Counter{cSubReqToE2, uint64(subReqCount)},
6020 Counter{cSubRespFromE2, uint64(subReqCount)},
6021 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
6022 Counter{cRestSubDelReqFromXapp, 1},
6023 Counter{cSubDelReqToE2, uint64(subReqCount)},
6024 Counter{cSubDelRespFromE2, uint64(subReqCount)},
6025 Counter{cRestSubDelRespToXapp, 1},
6029 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6030 restSubId := xappConn1.SendRESTSubsReq(t, params)
6031 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
6033 assert.Equal(t, len(e2SubsIds), subReqCount)
6036 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6037 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
6039 xappConn1.TestMsgChanEmpty(t)
6040 e2termConn1.TestMsgChanEmpty(t)
6041 mainCtrl.wait_registry_empty(t, 10)
6043 mainCtrl.VerifyCounterValues(t)
6044 mainCtrl.VerifyAllClean(t)
6047 //-----------------------------------------------------------------------------
6048 // TestRESTReportSubReqAndSubDelOk19E2Subs
6051 // +-------+ +---------+ +---------+
6052 // | xapp | | submgr | | e2term |
6053 // +-------+ +---------+ +---------+
6056 // |---------------->| |
6058 // | RESTSubResp | |
6059 // |<----------------| |
6062 // | |------------->|
6063 // | | | E2 subscription x 19
6065 // | |<-------------|
6067 // |<----------------| |
6069 // | RESTSubDelReq | |
6070 // |---------------->| |
6072 // | RESTSubDelResp| |
6073 // |<----------------| |
6074 // | | SubDelReq | ------
6075 // | |------------->|
6076 // | | | E2 subscription delete x 19
6078 // | |<-------------|
6082 //-----------------------------------------------------------------------------
6084 func TestRESTReportSubReqAndSubDelOk19E2Subs(t *testing.T) {
6088 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6089 Counter{cRestSubReqFromXapp, 1},
6090 Counter{cRestSubRespToXapp, 1},
6091 Counter{cSubReqToE2, uint64(subReqCount)},
6092 Counter{cSubRespFromE2, uint64(subReqCount)},
6093 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
6094 Counter{cRestSubDelReqFromXapp, 1},
6095 Counter{cSubDelReqToE2, uint64(subReqCount)},
6096 Counter{cSubDelRespFromE2, uint64(subReqCount)},
6097 Counter{cRestSubDelRespToXapp, 1},
6101 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6102 restSubId := xappConn1.SendRESTSubsReq(t, params)
6103 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
6105 assert.Equal(t, len(e2SubsIds), subReqCount)
6108 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6109 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
6111 xappConn1.TestMsgChanEmpty(t)
6112 e2termConn1.TestMsgChanEmpty(t)
6113 mainCtrl.wait_registry_empty(t, 10)
6115 mainCtrl.VerifyCounterValues(t)
6116 mainCtrl.VerifyAllClean(t)
6119 //-----------------------------------------------------------------------------
6120 // TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen
6123 // +-------+ +-------+ +---------+ +---------+
6124 // | xapp2 | | xapp1 | | submgr | | e2term |
6125 // +-------+ +-------+ +---------+ +---------+
6127 // | | RESTSubReq1 | |
6128 // | |------------->| |
6129 // | | RESTSubResp1 | |
6130 // | |<-------------| |
6133 // | | |------------->|
6135 // | RESTSubReq2 | |
6136 // |------------------------>| |
6137 // | RESTSubResp2 | |
6138 // |<------------------------| |
6141 // | | |------------->|
6144 // | | |<-------------|
6145 // | | RESTNotif1 | |
6146 // | |<-------------| |
6149 // | | |<-------------|
6151 // |<------------------------| |
6153 // | | [SUBS 1 DELETE] |
6155 // | | [SUBS 2 DELETE] |
6158 //-----------------------------------------------------------------------------
6160 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
6162 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6163 Counter{cRestSubReqFromXapp, 2},
6164 Counter{cRestSubRespToXapp, 2},
6165 Counter{cSubReqToE2, 2},
6166 Counter{cSubRespFromE2, 2},
6167 Counter{cRestSubNotifToXapp, 2},
6168 Counter{cRestSubDelReqFromXapp, 2},
6169 Counter{cSubDelReqToE2, 2},
6170 Counter{cSubDelRespFromE2, 2},
6171 Counter{cRestSubDelRespToXapp, 2},
6175 var params *teststube2ap.RESTSubsReqParams = nil
6178 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
6179 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
6181 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
6184 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
6185 params.SetMeid("RAN_NAME_1")
6186 eventTriggerDefinition := []int64{1234, 1}
6187 params.SetSubEventTriggerDefinition(eventTriggerDefinition)
6189 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
6190 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
6191 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6192 xappConn2.ExpectRESTNotification(t, restSubId2)
6193 e2termConn1.SendSubsResp(t, crereq, cremsg)
6194 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
6196 deleteXapp1Subscription(t, &restSubId1)
6197 deleteXapp2Subscription(t, &restSubId2)
6199 waitSubsCleanup(t, e2SubsId1, 10)
6200 waitSubsCleanup(t, e2SubsId2, 10)
6202 mainCtrl.VerifyCounterValues(t)
6203 mainCtrl.VerifyAllClean(t)
6206 //-----------------------------------------------------------------------------
6207 // TestRESTSubReqReportSameActionDiffActionListLen
6210 // +-------+ +-------+ +---------+ +---------+
6211 // | xapp2 | | xapp1 | | submgr | | e2term |
6212 // +-------+ +-------+ +---------+ +---------+
6214 // | | RESTSubReq1 | |
6215 // | |------------->| |
6216 // | | RESTSubResp1 | |
6217 // | |<-------------| |
6220 // | | |------------->|
6222 // | RESTSubReq2 | |
6223 // |------------------------>| |
6224 // | RESTSubResp2 | |
6225 // |<------------------------| |
6228 // | | |------------->|
6231 // | | |<-------------|
6232 // | | RESTNotif1 | |
6233 // | |<-------------| |
6236 // | | |<-------------|
6238 // |<------------------------| |
6240 // | | [SUBS 1 DELETE] |
6242 // | | [SUBS 2 DELETE] |
6245 //-----------------------------------------------------------------------------
6247 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
6249 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6250 Counter{cRestSubReqFromXapp, 2},
6251 Counter{cRestSubRespToXapp, 2},
6252 Counter{cSubReqToE2, 2},
6253 Counter{cSubRespFromE2, 2},
6254 Counter{cRestSubNotifToXapp, 2},
6255 Counter{cRestSubDelReqFromXapp, 2},
6256 Counter{cSubDelReqToE2, 2},
6257 Counter{cSubDelRespFromE2, 2},
6258 Counter{cRestSubDelRespToXapp, 2},
6262 var params *teststube2ap.RESTSubsReqParams = nil
6265 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
6266 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
6268 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
6271 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
6272 params.SetMeid("RAN_NAME_1")
6274 actionId := int64(1)
6275 actionType := "report"
6276 actionDefinition := []int64{5678, 1}
6277 subsequestActionType := "continue"
6278 timeToWait := "w10ms"
6279 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
6281 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
6282 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
6283 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6284 xappConn2.ExpectRESTNotification(t, restSubId2)
6285 e2termConn1.SendSubsResp(t, crereq, cremsg)
6286 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
6288 deleteXapp1Subscription(t, &restSubId1)
6289 deleteXapp2Subscription(t, &restSubId2)
6291 waitSubsCleanup(t, e2SubsId1, 10)
6292 waitSubsCleanup(t, e2SubsId2, 10)
6294 mainCtrl.VerifyCounterValues(t)
6295 mainCtrl.VerifyAllClean(t)
6298 //-----------------------------------------------------------------------------
6299 // TestRESTSubReqReportSameActionDiffActionID
6302 // +-------+ +-------+ +---------+ +---------+
6303 // | xapp2 | | xapp1 | | submgr | | e2term |
6304 // +-------+ +-------+ +---------+ +---------+
6306 // | | RESTSubReq1 | |
6307 // | |------------->| |
6308 // | | RESTSubResp1 | |
6309 // | |<-------------| |
6312 // | | |------------->|
6314 // | RESTSubReq2 | |
6315 // |------------------------>| |
6316 // | RESTSubResp2 | |
6317 // |<------------------------| |
6320 // | | |------------->|
6323 // | | |<-------------|
6324 // | | RESTNotif1 | |
6325 // | |<-------------| |
6328 // | | |<-------------|
6330 // |<------------------------| |
6332 // | | [SUBS 1 DELETE] |
6334 // | | [SUBS 2 DELETE] |
6337 //-----------------------------------------------------------------------------
6339 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
6341 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6342 Counter{cRestSubReqFromXapp, 2},
6343 Counter{cRestSubRespToXapp, 2},
6344 Counter{cSubReqToE2, 2},
6345 Counter{cSubRespFromE2, 2},
6346 Counter{cRestSubNotifToXapp, 2},
6347 Counter{cRestSubDelReqFromXapp, 2},
6348 Counter{cSubDelReqToE2, 2},
6349 Counter{cSubDelRespFromE2, 2},
6350 Counter{cRestSubDelRespToXapp, 2},
6354 var params *teststube2ap.RESTSubsReqParams = nil
6357 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
6358 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
6360 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
6363 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
6364 params.SetMeid("RAN_NAME_1")
6365 params.SetSubActionIDs(int64(2))
6367 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
6368 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
6369 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6370 xappConn2.ExpectRESTNotification(t, restSubId2)
6371 e2termConn1.SendSubsResp(t, crereq, cremsg)
6372 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
6374 deleteXapp1Subscription(t, &restSubId1)
6375 deleteXapp2Subscription(t, &restSubId2)
6377 waitSubsCleanup(t, e2SubsId1, 10)
6378 waitSubsCleanup(t, e2SubsId2, 10)
6380 mainCtrl.VerifyCounterValues(t)
6381 mainCtrl.VerifyAllClean(t)
6384 //-----------------------------------------------------------------------------
6385 // TestRESTSubReqDiffActionType
6388 // +-------+ +-------+ +---------+ +---------+
6389 // | xapp2 | | xapp1 | | submgr | | e2term |
6390 // +-------+ +-------+ +---------+ +---------+
6392 // | | RESTSubReq1 | |
6393 // | |------------->| |
6394 // | | RESTSubResp1 | |
6395 // | |<-------------| |
6398 // | | |------------->|
6400 // | RESTSubReq2 | |
6401 // |------------------------>| |
6402 // | RESTSubResp2 | |
6403 // |<------------------------| |
6406 // | | |------------->|
6409 // | | |<-------------|
6410 // | | RESTNotif1 | |
6411 // | |<-------------| |
6414 // | | |<-------------|
6416 // |<------------------------| |
6418 // | | [SUBS 1 DELETE] |
6420 // | | [SUBS 2 DELETE] |
6423 //-----------------------------------------------------------------------------
6425 func TestRESTSubReqDiffActionType(t *testing.T) {
6427 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6428 Counter{cRestSubReqFromXapp, 2},
6429 Counter{cRestSubRespToXapp, 2},
6430 Counter{cSubReqToE2, 2},
6431 Counter{cSubRespFromE2, 2},
6432 Counter{cRestSubNotifToXapp, 2},
6433 Counter{cRestSubDelReqFromXapp, 2},
6434 Counter{cSubDelReqToE2, 2},
6435 Counter{cSubDelRespFromE2, 2},
6436 Counter{cRestSubDelRespToXapp, 2},
6439 const e2Timeout int64 = 2
6440 const e2RetryCount int64 = 2
6441 const routingNeeded bool = true
6444 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6445 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6448 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
6449 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
6451 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
6454 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
6455 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6456 params.SetMeid("RAN_NAME_1")
6458 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
6459 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
6460 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6461 xappConn2.ExpectRESTNotification(t, restSubId2)
6462 e2termConn1.SendSubsResp(t, crereq, cremsg)
6463 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
6465 deleteXapp1Subscription(t, &restSubId1)
6466 deleteXapp2Subscription(t, &restSubId2)
6468 waitSubsCleanup(t, e2SubsId1, 10)
6469 waitSubsCleanup(t, e2SubsId2, 10)
6471 mainCtrl.VerifyCounterValues(t)
6472 mainCtrl.VerifyAllClean(t)
6475 //-----------------------------------------------------------------------------
6476 // TestRESTSubReqPolicyAndSubDelOkSameAction
6479 // +-------+ +-------+ +---------+ +---------+
6480 // | xapp2 | | xapp1 | | submgr | | e2term |
6481 // +-------+ +-------+ +---------+ +---------+
6483 // | | RESTSubReq1 | |
6484 // | |------------->| |
6485 // | | RESTSubResp1 | |
6486 // | |<-------------| |
6489 // | | |------------->|
6491 // | RESTSubReq2 | |
6492 // |------------------------>| |
6493 // | RESTSubResp2 | |
6494 // |<------------------------| |
6497 // | | |------------->|
6500 // | | |<-------------|
6501 // | | RESTNotif1 | |
6502 // | |<-------------| |
6505 // | | |<-------------|
6507 // |<------------------------| |
6509 // | | [SUBS 1 DELETE] |
6511 // | | [SUBS 2 DELETE] |
6514 //-----------------------------------------------------------------------------
6516 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
6518 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6519 Counter{cRestSubReqFromXapp, 2},
6520 Counter{cRestSubRespToXapp, 2},
6521 Counter{cSubReqToE2, 2},
6522 Counter{cSubRespFromE2, 2},
6523 Counter{cRestSubNotifToXapp, 2},
6524 Counter{cRestSubDelReqFromXapp, 2},
6525 Counter{cSubDelReqToE2, 2},
6526 Counter{cSubDelRespFromE2, 2},
6527 Counter{cRestSubDelRespToXapp, 2},
6530 const e2Timeout int64 = 2
6531 const e2RetryCount int64 = 2
6532 const routingNeeded bool = true
6535 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6536 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6539 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
6540 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
6542 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
6545 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
6546 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6547 params.SetMeid("RAN_NAME_1")
6549 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
6550 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
6551 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6552 xappConn2.ExpectRESTNotification(t, restSubId2)
6553 e2termConn1.SendSubsResp(t, crereq, cremsg)
6554 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
6556 deleteXapp1Subscription(t, &restSubId1)
6557 deleteXapp2Subscription(t, &restSubId2)
6559 waitSubsCleanup(t, e2SubsId1, 10)
6560 waitSubsCleanup(t, e2SubsId2, 10)
6562 mainCtrl.VerifyCounterValues(t)
6563 mainCtrl.VerifyAllClean(t)
6566 //-----------------------------------------------------------------------------
6567 // TestRESTSubReqReportSameActionDiffActionDefinitionLen
6570 // +-------+ +-------+ +---------+ +---------+
6571 // | xapp2 | | xapp1 | | submgr | | e2term |
6572 // +-------+ +-------+ +---------+ +---------+
6574 // | | RESTSubReq1 | |
6575 // | |------------->| |
6576 // | | RESTSubResp1 | |
6577 // | |<-------------| |
6580 // | | |------------->|
6582 // | RESTSubReq2 | |
6583 // |------------------------>| |
6584 // | RESTSubResp2 | |
6585 // |<------------------------| |
6588 // | | |------------->|
6591 // | | |<-------------|
6592 // | | RESTNotif1 | |
6593 // | |<-------------| |
6596 // | | |<-------------|
6598 // |<------------------------| |
6600 // | | [SUBS 1 DELETE] |
6602 // | | [SUBS 2 DELETE] |
6605 //-----------------------------------------------------------------------------
6607 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
6609 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6610 Counter{cRestSubReqFromXapp, 2},
6611 Counter{cRestSubRespToXapp, 2},
6612 Counter{cSubReqToE2, 2},
6613 Counter{cSubRespFromE2, 2},
6614 Counter{cRestSubNotifToXapp, 2},
6615 Counter{cRestSubDelReqFromXapp, 2},
6616 Counter{cSubDelReqToE2, 2},
6617 Counter{cSubDelRespFromE2, 2},
6618 Counter{cRestSubDelRespToXapp, 2},
6622 var params *teststube2ap.RESTSubsReqParams = nil
6625 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
6626 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
6628 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
6631 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
6632 params.SetMeid("RAN_NAME_1")
6633 actionDefinition := []int64{5678, 1}
6634 params.SetSubActionDefinition(actionDefinition)
6636 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
6637 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
6638 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6639 xappConn2.ExpectRESTNotification(t, restSubId2)
6640 e2termConn1.SendSubsResp(t, crereq, cremsg)
6641 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
6643 deleteXapp1Subscription(t, &restSubId1)
6644 deleteXapp2Subscription(t, &restSubId2)
6646 waitSubsCleanup(t, e2SubsId1, 10)
6647 waitSubsCleanup(t, e2SubsId2, 10)
6649 mainCtrl.VerifyCounterValues(t)
6650 mainCtrl.VerifyAllClean(t)
6653 //-----------------------------------------------------------------------------
6654 // TestRESTSubReqReportSameActionDiffActionDefinitionContents
6657 // +-------+ +-------+ +---------+ +---------+
6658 // | xapp2 | | xapp1 | | submgr | | e2term |
6659 // +-------+ +-------+ +---------+ +---------+
6661 // | | RESTSubReq1 | |
6662 // | |------------->| |
6663 // | | RESTSubResp1 | |
6664 // | |<-------------| |
6667 // | | |------------->|
6669 // | RESTSubReq2 | |
6670 // |------------------------>| |
6671 // | RESTSubResp2 | |
6672 // |<------------------------| |
6675 // | | |------------->|
6678 // | | |<-------------|
6679 // | | RESTNotif1 | |
6680 // | |<-------------| |
6683 // | | |<-------------|
6685 // |<------------------------| |
6687 // | | [SUBS 1 DELETE] |
6689 // | | [SUBS 2 DELETE] |
6692 //-----------------------------------------------------------------------------
6694 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
6696 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6697 Counter{cRestSubReqFromXapp, 2},
6698 Counter{cRestSubRespToXapp, 2},
6699 Counter{cSubReqToE2, 2},
6700 Counter{cSubRespFromE2, 2},
6701 Counter{cRestSubNotifToXapp, 2},
6702 Counter{cRestSubDelReqFromXapp, 2},
6703 Counter{cSubDelReqToE2, 2},
6704 Counter{cSubDelRespFromE2, 2},
6705 Counter{cRestSubDelRespToXapp, 2},
6709 var params *teststube2ap.RESTSubsReqParams = nil
6712 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
6713 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
6715 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
6718 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
6719 params.SetMeid("RAN_NAME_1")
6720 actionDefinition := []int64{56782}
6721 params.SetSubActionDefinition(actionDefinition)
6723 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
6724 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
6725 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6726 xappConn2.ExpectRESTNotification(t, restSubId2)
6727 e2termConn1.SendSubsResp(t, crereq, cremsg)
6728 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
6730 deleteXapp1Subscription(t, &restSubId1)
6731 deleteXapp2Subscription(t, &restSubId2)
6733 waitSubsCleanup(t, e2SubsId1, 10)
6734 waitSubsCleanup(t, e2SubsId2, 10)
6736 mainCtrl.VerifyCounterValues(t)
6737 mainCtrl.VerifyAllClean(t)
6740 //-----------------------------------------------------------------------------
6741 // TestRESTSubReqReportSameActionDiffSubsAction
6744 // +-------+ +-------+ +---------+ +---------+
6745 // | xapp2 | | xapp1 | | submgr | | e2term |
6746 // +-------+ +-------+ +---------+ +---------+
6748 // | | RESTSubReq1 | |
6749 // | |------------->| |
6750 // | | RESTSubResp1 | |
6751 // | |<-------------| |
6754 // | | |------------->|
6756 // | RESTSubReq2 | |
6757 // |------------------------>| |
6758 // | RESTSubResp2 | |
6759 // |<------------------------| |
6762 // | | |------------->|
6765 // | | |<-------------|
6766 // | | RESTNotif1 | |
6767 // | |<-------------| |
6770 // | | |<-------------|
6772 // |<------------------------| |
6774 // | | [SUBS 1 DELETE] |
6776 // | | [SUBS 2 DELETE] |
6779 //-----------------------------------------------------------------------------
6781 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
6783 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6784 Counter{cRestSubReqFromXapp, 2},
6785 Counter{cRestSubRespToXapp, 2},
6786 Counter{cSubReqToE2, 2},
6787 Counter{cSubRespFromE2, 2},
6788 Counter{cRestSubNotifToXapp, 2},
6789 Counter{cRestSubDelReqFromXapp, 2},
6790 Counter{cSubDelReqToE2, 2},
6791 Counter{cSubDelRespFromE2, 2},
6792 Counter{cRestSubDelRespToXapp, 2},
6796 var params *teststube2ap.RESTSubsReqParams = nil
6799 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
6800 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
6802 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
6805 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
6806 params.SetMeid("RAN_NAME_1")
6807 params.SetTimeToWait("w200ms")
6808 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
6809 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
6810 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6811 xappConn2.ExpectRESTNotification(t, restSubId2)
6812 e2termConn1.SendSubsResp(t, crereq, cremsg)
6813 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
6815 deleteXapp1Subscription(t, &restSubId1)
6816 deleteXapp2Subscription(t, &restSubId2)
6818 waitSubsCleanup(t, e2SubsId1, 10)
6819 waitSubsCleanup(t, e2SubsId2, 10)
6821 mainCtrl.VerifyCounterValues(t)
6822 mainCtrl.VerifyAllClean(t)
6825 //-----------------------------------------------------------------------------
6826 // TestRESTUnpackSubscriptionResponseDecodeFail
6829 // +-------+ +---------+ +---------+
6830 // | xapp | | submgr | | e2term |
6831 // +-------+ +---------+ +---------+
6834 // |---------------->| |
6836 // | RESTSubResp | |
6837 // |<----------------| |
6840 // | |------------->|
6842 // | | SubResp | ASN.1 decode fails
6843 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
6846 // | |------------->|
6848 // | | SubFail | Duplicated action
6849 // | |<-------------|
6850 // | RESTNotif (fail)| |
6851 // |<----------------| |
6853 // | [SUBS DELETE] |
6856 //-----------------------------------------------------------------------------
6858 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
6860 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6861 Counter{cRestSubReqFromXapp, 1},
6862 Counter{cRestSubRespToXapp, 1},
6863 Counter{cSubReqToE2, 1},
6864 Counter{cSubReqTimerExpiry, 1},
6865 Counter{cSubReReqToE2, 1},
6866 Counter{cSubRespFromE2, 1},
6867 Counter{cSubFailFromE2, 1},
6868 Counter{cRestSubFailNotifToXapp, 1},
6869 Counter{cRestSubDelReqFromXapp, 1},
6870 Counter{cRestSubDelRespToXapp, 1},
6873 const subReqCount int = 1
6876 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6877 restSubId := xappConn1.SendRESTSubsReq(t, params)
6879 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6880 // Decode of this response fails which will result resending original request
6881 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
6883 _, cremsg = e2termConn1.RecvSubsReq(t)
6885 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6887 // Subscription already created in E2 Node.
6888 fparams := &teststube2ap.E2StubSubsFailParams{}
6890 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6891 e2termConn1.SendSubsFail(t, fparams, cremsg)
6893 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6894 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6896 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6898 // Wait that subs is cleaned
6899 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6901 xappConn1.TestMsgChanEmpty(t)
6902 e2termConn1.TestMsgChanEmpty(t)
6903 mainCtrl.wait_registry_empty(t, 10)
6904 mainCtrl.VerifyAllClean(t)
6905 mainCtrl.VerifyCounterValues(t)
6908 //-----------------------------------------------------------------------------
6909 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
6912 // +-------+ +---------+ +---------+
6913 // | xapp | | submgr | | e2term |
6914 // +-------+ +---------+ +---------+
6917 // |---------------->| |
6919 // | RESTSubResp | |
6920 // |<----------------| |
6923 // | |------------->|
6925 // | | SubResp | Unknown instanceId
6926 // | |<-------------| No valid subscription found with subIds [0]
6929 // | |------------->|
6931 // | | SubFail | Duplicated action
6932 // | |<-------------| No valid subscription found with subIds [0]
6933 // | RESTNotif (fail)| |
6934 // |<----------------| |
6936 // | |------------->|
6939 // | |<-------------|
6941 // | [SUBS DELETE] |
6944 //-----------------------------------------------------------------------------
6946 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
6948 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6949 Counter{cRestSubReqFromXapp, 1},
6950 Counter{cRestSubRespToXapp, 1},
6951 Counter{cSubReqToE2, 1},
6952 Counter{cSubReqTimerExpiry, 2},
6953 Counter{cSubReReqToE2, 1},
6954 Counter{cSubRespFromE2, 1},
6955 Counter{cSubFailFromE2, 1},
6956 Counter{cRestSubFailNotifToXapp, 1},
6957 Counter{cRestSubDelReqFromXapp, 1},
6958 Counter{cRestSubDelRespToXapp, 1},
6959 Counter{cSubDelReqToE2, 1},
6960 Counter{cSubDelRespFromE2, 1},
6963 const subReqCount int = 1
6966 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6967 restSubId := xappConn1.SendRESTSubsReq(t, params)
6969 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6971 // Unknown instanceId 0 in this response which will result resending original request
6972 orgInstanceId := crereq.RequestId.InstanceId
6973 crereq.RequestId.InstanceId = 0
6974 e2termConn1.SendSubsResp(t, crereq, cremsg)
6976 _, cremsg = e2termConn1.RecvSubsReq(t)
6978 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6980 // Subscription already created in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
6981 fparams := &teststube2ap.E2StubSubsFailParams{}
6983 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6984 e2termConn1.SendSubsFail(t, fparams, cremsg)
6986 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6987 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6989 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6990 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6992 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6994 // Wait that subs is cleaned
6995 mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
6997 xappConn1.TestMsgChanEmpty(t)
6998 e2termConn1.TestMsgChanEmpty(t)
6999 mainCtrl.wait_registry_empty(t, 10)
7000 mainCtrl.VerifyAllClean(t)
7001 mainCtrl.VerifyCounterValues(t)
7004 //-----------------------------------------------------------------------------
7005 // TestRESTUnpackSubscriptionResponseNoTransaction
7008 // +-------+ +---------+ +---------+
7009 // | xapp | | submgr | | e2term |
7010 // +-------+ +---------+ +---------+
7013 // |---------------->| |
7015 // | RESTSubResp | |
7016 // |<----------------| |
7019 // | |------------->|
7021 // | | SubResp | No transaction for the response
7022 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
7025 // | |------------->|
7027 // | | SubFail | Duplicated action
7028 // | |<-------------|Ongoing transaction not found. This will result timer expiry and sending delete
7029 // | RESTNotif (fail)| |
7030 // |<----------------| |
7032 // | |------------->|
7035 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
7038 // | |------------->|
7041 // | |<-------------| Ongoing transaction not found.
7043 // | [SUBS DELETE] |
7046 //-----------------------------------------------------------------------------
7048 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
7050 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7051 Counter{cRestSubReqFromXapp, 1},
7052 Counter{cRestSubRespToXapp, 1},
7053 Counter{cSubReqToE2, 1},
7054 Counter{cSubReqTimerExpiry, 2},
7055 Counter{cSubReReqToE2, 1},
7056 Counter{cSubRespFromE2, 1},
7057 Counter{cSubFailFromE2, 1},
7058 Counter{cRestSubFailNotifToXapp, 1},
7059 Counter{cRestSubDelReqFromXapp, 1},
7060 Counter{cRestSubDelRespToXapp, 1},
7061 Counter{cSubDelReqToE2, 1},
7062 Counter{cSubDelReqTimerExpiry, 2},
7063 Counter{cSubDelReReqToE2, 1},
7064 Counter{cSubDelRespFromE2, 2},
7067 const subReqCount int = 1
7070 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7071 restSubId := xappConn1.SendRESTSubsReq(t, params)
7073 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7075 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
7076 // No transaction exist for this response which will result resending original request
7077 e2termConn1.SendSubsResp(t, crereq, cremsg)
7079 _, cremsg = e2termConn1.RecvSubsReq(t)
7081 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7083 // Subscription already created in E2 Node.
7084 fparams := &teststube2ap.E2StubSubsFailParams{}
7086 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
7087 e2termConn1.SendSubsFail(t, fparams, cremsg)
7089 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7090 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7092 // Resending happens because there no transaction
7093 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
7094 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7096 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
7097 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
7099 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7101 // Wait that subs is cleaned
7102 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
7104 xappConn1.TestMsgChanEmpty(t)
7105 e2termConn1.TestMsgChanEmpty(t)
7106 mainCtrl.wait_registry_empty(t, 10)
7107 mainCtrl.VerifyAllClean(t)
7108 mainCtrl.VerifyCounterValues(t)
7111 //-----------------------------------------------------------------------------
7112 // TestRESTUnpackSubscriptionFailureDecodeFail
7115 // +-------+ +---------+ +---------+
7116 // | xapp | | submgr | | e2term |
7117 // +-------+ +---------+ +---------+
7120 // |---------------->| |
7122 // | RESTSubResp | |
7123 // |<----------------| |
7126 // | |------------->|
7128 // | | SubFail | ASN.1 decode fails
7129 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
7132 // | |------------->|
7134 // | | SubFail | Duplicated action
7135 // | |<-------------|
7136 // | RESTNotif (fail)| |
7137 // |<----------------| |
7139 // | [SUBS DELETE] |
7142 //-----------------------------------------------------------------------------
7144 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
7146 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7147 Counter{cRestSubReqFromXapp, 1},
7148 Counter{cRestSubRespToXapp, 1},
7149 Counter{cSubReqToE2, 1},
7150 Counter{cSubReqTimerExpiry, 1},
7151 Counter{cSubReReqToE2, 1},
7152 Counter{cSubFailFromE2, 2},
7153 Counter{cRestSubFailNotifToXapp, 1},
7154 Counter{cRestSubDelReqFromXapp, 1},
7155 Counter{cRestSubDelRespToXapp, 1},
7158 const subReqCount int = 1
7161 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7162 restSubId := xappConn1.SendRESTSubsReq(t, params)
7164 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7166 // Decode of this response fails which will result resending original request
7167 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
7169 _, cremsg = e2termConn1.RecvSubsReq(t)
7171 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7173 // Subscription already created in E2 Node.
7174 fparams := &teststube2ap.E2StubSubsFailParams{}
7176 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
7177 e2termConn1.SendSubsFail(t, fparams, cremsg)
7179 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
7180 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
7182 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7184 // Wait that subs is cleaned
7185 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
7187 xappConn1.TestMsgChanEmpty(t)
7188 e2termConn1.TestMsgChanEmpty(t)
7189 mainCtrl.wait_registry_empty(t, 10)
7190 mainCtrl.VerifyAllClean(t)
7191 mainCtrl.VerifyCounterValues(t)
7194 //-----------------------------------------------------------------------------
7195 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
7198 // +-------+ +---------+ +---------+
7199 // | xapp | | submgr | | e2term |
7200 // +-------+ +---------+ +---------+
7203 // |---------------->| |
7205 // | RESTSubResp | |
7206 // |<----------------| |
7209 // | |------------->|
7211 // | | SubFail | Unknown instanceId
7212 // | |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
7215 // | |------------->|
7217 // | | SubFail | Duplicated action
7218 // | |<-------------|No valid subscription found with subIds [0]. This will result timer expiry and sending delete
7219 // | RESTNotif (fail)| |
7220 // |<----------------| |
7222 // | |------------->|
7225 // | |<-------------|
7227 // | [SUBS DELETE] |
7230 //-----------------------------------------------------------------------------
7231 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
7233 const subReqCount int = 1
7235 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7236 Counter{cRestSubReqFromXapp, 1},
7237 Counter{cRestSubRespToXapp, 1},
7238 Counter{cSubReqToE2, 1},
7239 Counter{cSubReqTimerExpiry, 2},
7240 Counter{cSubReReqToE2, 1},
7241 Counter{cSubFailFromE2, 2},
7242 Counter{cRestSubFailNotifToXapp, 1},
7243 Counter{cRestSubDelReqFromXapp, 1},
7244 Counter{cRestSubDelRespToXapp, 1},
7245 Counter{cSubDelReqToE2, 1},
7246 Counter{cSubDelRespFromE2, 1},
7250 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7251 restSubId := xappConn1.SendRESTSubsReq(t, params)
7253 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7255 // Unknown instanceId 0 in this response which will result resending original request
7256 fparams := &teststube2ap.E2StubSubsFailParams{}
7258 fparams.Fail.RequestId.InstanceId = 0
7259 e2termConn1.SendSubsFail(t, fparams, cremsg)
7261 _, cremsg = e2termConn1.RecvSubsReq(t)
7263 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7265 // Subscription already created in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
7266 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
7267 e2termConn1.SendSubsFail(t, fparams, cremsg)
7269 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7270 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7272 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
7273 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
7275 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7277 // Wait that subs is cleaned
7278 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
7280 xappConn1.TestMsgChanEmpty(t)
7281 e2termConn1.TestMsgChanEmpty(t)
7282 mainCtrl.wait_registry_empty(t, 10)
7283 mainCtrl.VerifyAllClean(t)
7284 mainCtrl.VerifyCounterValues(t)
7287 //-----------------------------------------------------------------------------
7288 // TestRESTUnpackSubscriptionFailureNoTransaction
7291 // +-------+ +---------+ +---------+
7292 // | xapp | | submgr | | e2term |
7293 // +-------+ +---------+ +---------+
7296 // |---------------->| |
7298 // | RESTSubResp | |
7299 // |<----------------| |
7302 // | |------------->|
7304 // | | SubFail | No transaction for the response
7305 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
7308 // | |------------->|
7310 // | | SubFail | Duplicated action
7311 // | |<-------------| Ongoing transaction not found. This will result timer expiry and sending delete
7312 // | RESTNotif (fail)| |
7313 // |<----------------| |
7315 // | |------------->|
7318 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
7321 // | |------------->|
7324 // | |<-------------| Ongoing transaction not found.
7326 // | [SUBS DELETE] |
7329 //-----------------------------------------------------------------------------
7331 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
7333 const subReqCount int = 1
7335 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7336 Counter{cRestSubReqFromXapp, 1},
7337 Counter{cRestSubRespToXapp, 1},
7338 Counter{cSubReqToE2, 1},
7339 Counter{cSubReqTimerExpiry, 2},
7340 Counter{cSubReReqToE2, 1},
7341 Counter{cSubFailFromE2, 2},
7342 Counter{cRestSubFailNotifToXapp, 1},
7343 Counter{cRestSubDelReqFromXapp, 1},
7344 Counter{cRestSubDelRespToXapp, 1},
7345 Counter{cSubDelReqToE2, 1},
7346 Counter{cSubDelReqTimerExpiry, 2},
7347 Counter{cSubDelReReqToE2, 1},
7348 Counter{cSubDelRespFromE2, 2},
7352 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7353 restSubId := xappConn1.SendRESTSubsReq(t, params)
7355 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7357 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
7359 // No transaction exist for this response which will result resending original request
7360 fparams := &teststube2ap.E2StubSubsFailParams{}
7362 e2termConn1.SendSubsFail(t, fparams, cremsg)
7364 _, cremsg = e2termConn1.RecvSubsReq(t)
7366 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7368 // Subscription already created in E2 Node.
7369 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
7370 e2termConn1.SendSubsFail(t, fparams, cremsg)
7372 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7373 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7375 // Resending happens because there no transaction
7376 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
7377 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7379 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
7380 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
7382 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7384 // Wait that subs is cleaned
7385 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
7387 xappConn1.TestMsgChanEmpty(t)
7388 e2termConn1.TestMsgChanEmpty(t)
7389 mainCtrl.wait_registry_empty(t, 10)
7390 mainCtrl.VerifyAllClean(t)
7391 mainCtrl.VerifyCounterValues(t)
7394 //-----------------------------------------------------------------------------
7395 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
7398 // +-------+ +---------+ +---------+
7399 // | xapp | | submgr | | e2term |
7400 // +-------+ +---------+ +---------+
7402 // | [SUBS CREATE] |
7405 // | RESTSubDelReq | |
7406 // |---------------->| |
7408 // | RESTSubDelResp | |
7409 // |<----------------| |
7412 // | |------------->|
7414 // | | SubDelResp | ASN.1 decode fails.
7415 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
7418 // | |------------->|
7420 // | | SubDelFail | Subscription does exist any more in E2 node
7421 // | |<-------------|
7423 // | [SUBS DELETE] |
7426 //-----------------------------------------------------------------------------
7428 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
7430 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7431 Counter{cRestSubReqFromXapp, 1},
7432 Counter{cRestSubRespToXapp, 1},
7433 Counter{cSubReqToE2, 1},
7434 Counter{cSubRespFromE2, 1},
7435 Counter{cRestSubNotifToXapp, 1},
7436 Counter{cRestSubDelReqFromXapp, 1},
7437 Counter{cRestSubDelRespToXapp, 1},
7438 Counter{cSubDelReqToE2, 1},
7439 Counter{cSubDelReqTimerExpiry, 1},
7440 Counter{cSubDelReReqToE2, 1},
7441 Counter{cSubDelFailFromE2, 1},
7442 Counter{cSubDelRespFromE2, 1},
7446 var params *teststube2ap.RESTSubsReqParams = nil
7447 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
7450 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7452 // E2t: Receive 1st SubsDelReq
7453 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7455 // Decode of this response fails which will result resending original request
7456 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_RESP)
7458 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
7459 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
7461 // Subscription does not exist in in E2 Node.
7462 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
7464 // Wait that subs is cleaned
7465 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
7467 xappConn1.TestMsgChanEmpty(t)
7468 e2termConn1.TestMsgChanEmpty(t)
7469 mainCtrl.wait_registry_empty(t, 10)
7470 mainCtrl.VerifyAllClean(t)
7471 mainCtrl.VerifyCounterValues(t)
7474 //-----------------------------------------------------------------------------
7475 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
7478 // +-------+ +---------+ +---------+
7479 // | xapp | | submgr | | e2term |
7480 // +-------+ +---------+ +---------+
7482 // | [SUBS CREATE] |
7485 // | RESTSubDelReq | |
7486 // |---------------->| |
7488 // | RESTSubDelResp | |
7489 // |<----------------| |
7492 // | |------------->|
7494 // | | SubDelResp | Unknown instanceId
7495 // | |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
7498 // | |------------->|
7500 // | | SubDelFail | Subscription does exist any more in E2 node
7501 // | |<-------------|
7503 // | [SUBS DELETE] |
7505 //-----------------------------------------------------------------------------
7507 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
7509 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7510 Counter{cRestSubReqFromXapp, 1},
7511 Counter{cRestSubRespToXapp, 1},
7512 Counter{cSubReqToE2, 1},
7513 Counter{cSubRespFromE2, 1},
7514 Counter{cRestSubNotifToXapp, 1},
7515 Counter{cRestSubDelReqFromXapp, 1},
7516 Counter{cRestSubDelRespToXapp, 1},
7517 Counter{cSubDelReqToE2, 1},
7518 Counter{cSubDelReqTimerExpiry, 1},
7519 Counter{cSubDelReReqToE2, 1},
7520 Counter{cSubDelRespFromE2, 1},
7521 Counter{cSubDelFailFromE2, 1},
7525 var params *teststube2ap.RESTSubsReqParams = nil
7526 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
7529 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7531 // E2t: Receive 1st SubsDelReq
7532 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7534 // Unknown instanceId in this response which will result resending original request
7535 delreq.RequestId.InstanceId = 0
7536 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7538 // E2t: Receive 2nd SubsDelReq
7539 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
7541 // Subscription does not exist in in E2 Node.
7542 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
7544 // Wait that subs is cleaned
7545 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
7547 xappConn1.TestMsgChanEmpty(t)
7548 e2termConn1.TestMsgChanEmpty(t)
7549 mainCtrl.wait_registry_empty(t, 10)
7550 mainCtrl.VerifyAllClean(t)
7551 mainCtrl.VerifyCounterValues(t)
7554 //-----------------------------------------------------------------------------
7555 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
7558 // +-------+ +---------+ +---------+
7559 // | xapp | | submgr | | e2term |
7560 // +-------+ +---------+ +---------+
7562 // | [SUBS CREATE] |
7565 // | RESTSubDelReq | |
7566 // |---------------->| |
7568 // | RESTSubDelResp | |
7569 // |<----------------| |
7572 // | |------------->|
7574 // | | SubDelResp | No transaction for the response
7575 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
7578 // | |------------->|
7580 // | | SubDelFail | Subscription does exist any more in E2 node
7581 // | |<-------------| Ongoing transaction not found. This will result timer expiry
7583 // | [SUBS DELETE] |
7585 //-----------------------------------------------------------------------------
7587 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
7589 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7590 Counter{cRestSubReqFromXapp, 1},
7591 Counter{cRestSubRespToXapp, 1},
7592 Counter{cSubReqToE2, 1},
7593 Counter{cSubRespFromE2, 1},
7594 Counter{cRestSubNotifToXapp, 1},
7595 Counter{cRestSubDelReqFromXapp, 1},
7596 Counter{cRestSubDelRespToXapp, 1},
7597 Counter{cSubDelReqToE2, 1},
7598 Counter{cSubDelReqTimerExpiry, 2},
7599 Counter{cSubDelReReqToE2, 1},
7600 Counter{cSubDelRespFromE2, 1},
7601 Counter{cSubDelFailFromE2, 1},
7605 var params *teststube2ap.RESTSubsReqParams = nil
7606 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
7609 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7611 // E2t: Receive 1st SubsDelReq
7612 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7614 mainCtrl.MakeTransactionNil(t, e2SubsId)
7616 // No transaction exist for this response which will result resending original request
7617 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7619 // E2t: Receive 2nd SubsDelReq
7620 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
7622 // Subscription does not exist in in E2 Node.
7623 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
7625 // Wait that subs is cleaned
7626 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
7628 xappConn1.TestMsgChanEmpty(t)
7629 e2termConn1.TestMsgChanEmpty(t)
7630 mainCtrl.wait_registry_empty(t, 10)
7631 mainCtrl.VerifyAllClean(t)
7632 mainCtrl.VerifyCounterValues(t)
7635 //-----------------------------------------------------------------------------
7636 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
7639 // +-------+ +---------+ +---------+
7640 // | xapp | | submgr | | e2term |
7641 // +-------+ +---------+ +---------+
7643 // | [SUBS CREATE] |
7646 // | RESTSubDelReq | |
7647 // |---------------->| |
7649 // | RESTSubDelResp | |
7650 // |<----------------| |
7653 // | |------------->|
7655 // | | SubDelFail | ASN.1 decode fails
7656 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
7659 // | |------------->|
7661 // | | SubDelFail | Subscription does exist any more in E2 node
7662 // | |<-------------|
7664 // | [SUBS DELETE] |
7666 //-----------------------------------------------------------------------------
7668 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
7670 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7671 Counter{cRestSubReqFromXapp, 1},
7672 Counter{cRestSubRespToXapp, 1},
7673 Counter{cSubReqToE2, 1},
7674 Counter{cSubRespFromE2, 1},
7675 Counter{cRestSubNotifToXapp, 1},
7676 Counter{cRestSubDelReqFromXapp, 1},
7677 Counter{cRestSubDelRespToXapp, 1},
7678 Counter{cSubDelReqToE2, 1},
7679 Counter{cSubDelReqTimerExpiry, 1},
7680 Counter{cSubDelReReqToE2, 1},
7681 Counter{cSubDelFailFromE2, 2},
7685 var params *teststube2ap.RESTSubsReqParams = nil
7686 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
7689 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7691 // E2t: Receive 1st SubsDelReq
7692 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7694 // Decode of this response fails which will result resending original request
7695 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
7697 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
7698 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
7700 // Subscription does not exist in in E2 Node.
7701 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
7703 // Wait that subs is cleaned
7704 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
7706 xappConn1.TestMsgChanEmpty(t)
7707 e2termConn1.TestMsgChanEmpty(t)
7708 mainCtrl.wait_registry_empty(t, 10)
7709 mainCtrl.VerifyAllClean(t)
7710 mainCtrl.VerifyCounterValues(t)
7713 //-----------------------------------------------------------------------------
7714 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
7717 // +-------+ +---------+ +---------+
7718 // | xapp | | submgr | | e2term |
7719 // +-------+ +---------+ +---------+
7721 // | [SUBS CREATE] |
7724 // | RESTSubDelReq | |
7725 // |---------------->| |
7727 // | RESTSubDelResp | |
7728 // |<----------------| |
7731 // | |------------->|
7733 // | | SubDelFail | Unknown instanceId
7734 // | |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
7737 // | |------------->|
7739 // | | SubDelFail | Subscription does exist any more in E2 node
7740 // | |<-------------| No valid subscription found with subIds [0].
7742 // | [SUBS DELETE] |
7744 //-----------------------------------------------------------------------------
7746 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
7748 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7749 Counter{cRestSubReqFromXapp, 1},
7750 Counter{cRestSubRespToXapp, 1},
7751 Counter{cSubReqToE2, 1},
7752 Counter{cSubRespFromE2, 1},
7753 Counter{cRestSubNotifToXapp, 1},
7754 Counter{cRestSubDelReqFromXapp, 1},
7755 Counter{cRestSubDelRespToXapp, 1},
7756 Counter{cSubDelReqToE2, 1},
7757 Counter{cSubDelReqTimerExpiry, 1},
7758 Counter{cSubDelReReqToE2, 1},
7759 Counter{cSubDelFailFromE2, 2},
7763 var params *teststube2ap.RESTSubsReqParams = nil
7764 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
7767 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7769 // E2t: Receive 1st SubsDelReq
7770 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7772 // Unknown instanceId 0 in this response which will result resending original request
7773 delreq.RequestId.InstanceId = 0
7774 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
7776 // E2t: Receive 2nd SubsDelReq
7777 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
7779 // Subscription does not exist in in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
7780 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
7782 // Wait that subs is cleaned
7783 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
7785 xappConn1.TestMsgChanEmpty(t)
7786 e2termConn1.TestMsgChanEmpty(t)
7787 mainCtrl.wait_registry_empty(t, 10)
7788 mainCtrl.VerifyAllClean(t)
7789 mainCtrl.VerifyCounterValues(t)
7792 //-----------------------------------------------------------------------------
7793 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
7796 // +-------+ +---------+ +---------+
7797 // | xapp | | submgr | | e2term |
7798 // +-------+ +---------+ +---------+
7800 // | [SUBS CREATE] |
7803 // | RESTSubDelReq | |
7804 // |---------------->| |
7806 // | RESTSubDelResp | |
7807 // |<----------------| |
7810 // | |------------->|
7812 // | | SubDelFail | No transaction for the response
7813 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
7816 // | |------------->|
7818 // | | SubDelFail | Subscription does exist any more in E2 node
7819 // | |<-------------| Ongoing transaction not found. This will result timer expiry
7821 // | [SUBS DELETE] |
7823 //-----------------------------------------------------------------------------
7825 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
7827 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7828 Counter{cRestSubReqFromXapp, 1},
7829 Counter{cRestSubRespToXapp, 1},
7830 Counter{cSubReqToE2, 1},
7831 Counter{cSubRespFromE2, 1},
7832 Counter{cRestSubNotifToXapp, 1},
7833 Counter{cRestSubDelReqFromXapp, 1},
7834 Counter{cRestSubDelRespToXapp, 1},
7835 Counter{cSubDelReqToE2, 1},
7836 Counter{cSubDelReqTimerExpiry, 2},
7837 Counter{cSubDelReReqToE2, 1},
7838 Counter{cSubDelFailFromE2, 2},
7842 var params *teststube2ap.RESTSubsReqParams = nil
7843 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
7846 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7848 // E2t: Receive 1st SubsDelReq
7849 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7851 mainCtrl.MakeTransactionNil(t, e2SubsId)
7853 // No transaction exist for this response which will result resending original request
7854 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
7856 // E2t: Receive 2nd SubsDelReq
7857 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
7859 // Subscription does not exist in in E2 Node.
7860 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
7862 // Wait that subs is cleaned
7863 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
7865 xappConn1.TestMsgChanEmpty(t)
7866 e2termConn1.TestMsgChanEmpty(t)
7867 mainCtrl.wait_registry_empty(t, 10)
7868 mainCtrl.VerifyAllClean(t)
7869 mainCtrl.VerifyCounterValues(t)
7872 //-----------------------------------------------------------------------------
7873 // TestRESTSubReqFailAsn1PackSubReqError
7876 // +-------+ +---------+ +---------+
7877 // | xapp | | submgr | | e2term |
7878 // +-------+ +---------+ +---------+
7881 // |---------------->| |
7883 // | RESTSubResp | |
7884 // |<----------------| |
7886 // | ASN.1 encode fails |
7889 // | |------------->|
7892 // | |<-------------|
7896 // |<----------------| |
7898 // | [SUBS DELETE] |
7901 //-----------------------------------------------------------------------------
7903 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
7905 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7906 Counter{cRestSubReqFromXapp, 1},
7907 Counter{cRestSubRespToXapp, 1},
7908 Counter{cRestSubFailNotifToXapp, 1},
7909 Counter{cRestSubDelReqFromXapp, 1},
7910 Counter{cRestSubDelRespToXapp, 1},
7913 const subReqCount int = 1
7915 var params *teststube2ap.RESTSubsReqParams = nil
7916 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
7917 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
7920 restSubId := xappConn1.SendRESTSubsReq(t, params)
7921 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
7923 // E2t: Receive SubsDelReq
7924 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7926 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7927 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
7929 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
7931 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7933 // Wait that subs is cleaned
7934 waitSubsCleanup(t, e2SubsId, 10)
7935 mainCtrl.VerifyAllClean(t)
7936 mainCtrl.VerifyCounterValues(t)
7939 //-----------------------------------------------------------------------------
7940 // TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction
7943 // +-------+ +---------+ +---------+
7944 // | xapp | | submgr | | e2term |
7945 // +-------+ +---------+ +---------+
7948 // |---------------->| |
7950 // | RESTSubResp | |
7951 // |<----------------| |
7953 // | |------------->|
7956 // | |<-------------|
7959 // |<----------------| |
7961 // | RESTSubReq | | Policy modification
7962 // |---------------->| |
7964 // | RESTSubResp | |
7965 // |<----------------| |
7967 // | |------------->|
7970 // | RESTNotif(Unsuccessful) | E2 timeout
7971 // |<----------------| |
7973 // | RESTSubDelReq | |
7974 // |---------------->| |
7977 // | |------------->|
7980 // | |<-------------|
7982 // | RESTSubDelResp | |
7983 // |<----------------| |
7985 //-----------------------------------------------------------------------------
7987 func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
7989 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7990 Counter{cRestSubReqFromXapp, 2},
7991 Counter{cRestSubRespToXapp, 2},
7992 Counter{cSubReqToE2, 2},
7993 Counter{cSubReqTimerExpiry, 1},
7994 Counter{cSubRespFromE2, 1},
7995 Counter{cRestSubNotifToXapp, 1},
7996 Counter{cRestSubFailNotifToXapp, 1},
7997 Counter{cRestSubDelReqFromXapp, 1},
7998 Counter{cSubDelReqToE2, 1},
7999 Counter{cSubDelRespFromE2, 1},
8000 Counter{cRestSubDelRespToXapp, 1},
8003 const e2Timeout int64 = 1
8004 const e2RetryCount int64 = 0
8005 const routingNeeded bool = false
8008 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
8009 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
8012 restSubId := xappConn1.SendRESTSubsReq(t, params)
8013 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
8015 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
8016 xappConn1.ExpectRESTNotification(t, restSubId)
8017 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
8018 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8019 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
8022 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
8023 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
8024 params.SetSubscriptionID(&restSubId)
8025 params.SetTimeToWait("w200ms")
8026 restSubId = xappConn1.SendRESTSubsReq(t, params)
8027 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
8029 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
8030 xappConn1.ExpectRESTNotification(t, restSubId)
8031 // SubsResp is missing, e2SubsId will be 0
8032 zeroE2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8033 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", zeroE2SubsId)
8036 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8037 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8038 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8040 waitSubsCleanup(t, e2SubsId, 10)
8041 mainCtrl.VerifyAllClean(t)
8042 mainCtrl.VerifyCounterValues(t)
8045 //-----------------------------------------------------------------------------
8046 // TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle
8049 // +-------+ +---------+ +---------+
8050 // | xapp | | submgr | | e2term |
8051 // +-------+ +---------+ +---------+
8054 // |---------------->| |
8056 // | RESTSubResp | |
8057 // |<----------------| |
8059 // | |------------->|
8062 // | |<-------------|
8065 // |<----------------| |
8068 // |---------------->| |
8070 // | RESTSubResp | |
8071 // |<----------------| |
8073 // | |------------->|
8075 // | Submgr restart |
8077 // | RESTSubDelReq | |
8078 // |---------------->| |
8081 // | |------------->|
8084 // | |<-------------|
8086 // | RESTSubDelResp | |
8087 // |<----------------| |
8089 //-----------------------------------------------------------------------------
8091 func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
8093 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8094 Counter{cRestSubReqFromXapp, 2},
8095 Counter{cRestSubRespToXapp, 2},
8096 Counter{cSubReqToE2, 2},
8097 Counter{cSubRespFromE2, 1},
8098 Counter{cRestSubNotifToXapp, 1},
8099 Counter{cRestSubDelReqFromXapp, 1},
8100 Counter{cSubDelReqToE2, 1},
8101 Counter{cSubDelRespFromE2, 1},
8102 Counter{cRestSubDelRespToXapp, 1},
8105 const e2Timeout int64 = 1
8106 const e2RetryCount int64 = 0
8107 const routingNeeded bool = false
8110 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
8111 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
8112 // Create subscription
8113 restSubId := xappConn1.SendRESTSubsReq(t, params)
8114 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
8116 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
8117 xappConn1.ExpectRESTNotification(t, restSubId)
8118 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
8119 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8120 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
8122 // Check subscription
8123 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
8126 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
8127 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
8128 params.SetSubscriptionID(&restSubId)
8129 params.SetTimeToWait("w200ms")
8130 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
8131 restSubId = xappConn1.SendRESTSubsReq(t, params)
8132 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
8134 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
8135 mainCtrl.SetResetTestFlag(t, false)
8137 // SubsResp is missing due to submgr restart
8139 mainCtrl.SimulateRestart(t)
8140 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
8142 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
8143 // That needs to be completed before successful subscription query is possible
8144 <-time.After(time.Second * 1)
8146 // Check subscription
8147 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
8149 // Delete subscription
8150 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8151 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8152 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8154 //Wait that subs is cleaned
8155 waitSubsCleanup(t, e2SubsId, 10)
8157 mainCtrl.VerifyCounterValues(t)
8158 mainCtrl.VerifyAllClean(t)
8161 ////////////////////////////////////////////////////////////////////////////////////
8162 // Services for UT cases
8163 ////////////////////////////////////////////////////////////////////////////////////
8164 const subReqCount int = 1
8165 const host string = "localhost"
8167 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
8169 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
8171 restSubId := fromXappConn.SendRESTSubsReq(t, params)
8172 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
8174 crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
8175 fromXappConn.ExpectRESTNotification(t, restSubId)
8176 toE2termConn.SendSubsResp(t, crereq1, cremsg1)
8177 e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
8178 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
8180 return restSubId, e2SubsId
8183 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
8185 params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
8187 params.SetMeid(meid)
8189 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
8190 restSubId := xappConn2.SendRESTSubsReq(t, params)
8191 xappConn2.ExpectRESTNotification(t, restSubId)
8192 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
8193 e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
8194 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
8196 return restSubId, e2SubsId
8199 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
8201 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
8202 restSubId := xappConn1.SendRESTSubsReq(t, params)
8203 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
8205 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
8206 xappConn1.ExpectRESTNotification(t, restSubId)
8207 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
8208 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8209 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
8211 return restSubId, e2SubsId
8214 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
8215 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
8216 restSubId := xappConn1.SendRESTSubsReq(t, params)
8218 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
8219 fparams1 := &teststube2ap.E2StubSubsFailParams{}
8220 fparams1.Set(crereq1)
8221 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
8223 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
8224 xappConn1.ExpectRESTNotification(t, restSubId)
8225 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
8226 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8227 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
8229 return restSubId, e2SubsId
8232 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
8233 fromXappConn.SendRESTSubsDelReq(t, restSubId)
8234 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
8235 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
8238 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
8239 xappConn1.SendRESTSubsDelReq(t, restSubId)
8240 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8241 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8244 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
8245 xappConn2.SendRESTSubsDelReq(t, restSubId)
8246 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8247 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8250 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
8251 resp, _ := xapp.Subscription.QuerySubscriptions()
8252 assert.Equal(t, e2SubsId, resp[0].SubscriptionID)
8253 assert.Equal(t, meid, resp[0].Meid)
8254 assert.Equal(t, endpoint, resp[0].ClientEndpoint)
8257 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
8258 //Wait that subs is cleaned
8259 mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
8261 xappConn1.TestMsgChanEmpty(t)
8262 xappConn2.TestMsgChanEmpty(t)
8263 e2termConn1.TestMsgChanEmpty(t)
8264 mainCtrl.wait_registry_empty(t, timeout)
8267 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
8269 var e2SubsId []uint32
8271 for i := 0; i < count; i++ {
8272 xapp.Logger.Debug("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
8273 crereq, cremsg := toE2termConn.RecvSubsReq(t)
8274 fromXappConn.ExpectRESTNotification(t, restSubId)
8275 toE2termConn.SendSubsResp(t, crereq, cremsg)
8276 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
8277 e2SubsId = append(e2SubsId, instanceId)
8278 xapp.Logger.Debug("TEST: %v", e2SubsId)
8279 xapp.Logger.Debug("TEST: %d ===================================== END CRE ============================================", i+1)
8280 <-time.After(100 * time.Millisecond)
8285 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
8287 for i := 0; i < len(e2SubsIds); i++ {
8288 xapp.Logger.Debug("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
8289 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
8290 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
8291 <-time.After(1 * time.Second)
8292 xapp.Logger.Debug("TEST: %d ===================================== END DEL ============================================", i+1)
8293 <-time.After(100 * time.Millisecond)
8296 // Wait that subs is cleaned
8297 for i := 0; i < len(e2SubsIds); i++ {
8298 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)