2 ==================================================================================
3 Copyright (c) 2019 AT&T Intellectual Property.
4 Copyright (c) 2019 Nokia
6 Licensed under the Apache License, Version 2.0 (the "License");
7 you may not use this file except in compliance with the License.
8 You may obtain a copy of the License at
10 http://www.apache.org/licenses/LICENSE-2.0
12 Unless required by applicable law or agreed to in writing, software
13 distributed under the License is distributed on an "AS IS" BASIS,
14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 See the License for the specific language governing permissions and
16 limitations under the License.
17 ==================================================================================
28 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
29 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper"
30 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
31 "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststube2ap"
32 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
33 "github.com/stretchr/testify/assert"
36 func TestSuiteSetup(t *testing.T) {
37 // The effect of this call shall endure though the UT suite!
38 // If this causes any issues, the previous interface can be restored
40 // SetPackerIf(e2ap_wrapper.NewAsn1E2APPacker())
42 mainCtrl.InitAllCounterMap()
43 SetPackerIf(e2ap_wrapper.NewUtAsn1E2APPacker())
44 mainCtrl.c.restDuplicateCtrl.Init()
47 func TestRanStatusChangeViaSDLNotification(t *testing.T) {
49 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
50 Counter{cE2StateChangedToUp, 3},
53 // Current UT test cases use these ran names
54 xappRnibMock.CreateGnb("RAN_NAME_1", entities.ConnectionStatus_DISCONNECTED)
55 xappRnibMock.CreateGnb("RAN_NAME_11", entities.ConnectionStatus_DISCONNECTED)
56 xappRnibMock.CreateGnb("RAN_NAME_2", entities.ConnectionStatus_DISCONNECTED)
58 mainCtrl.c.e2IfState.ReadE2ConfigurationFromRnib()
59 mainCtrl.c.e2IfState.SubscribeChannels()
61 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
62 mainCtrl.SetE2State(t, "RAN_NAME_2_CONNECTED")
63 mainCtrl.SetE2State(t, "RAN_NAME_11_CONNECTED")
65 mainCtrl.VerifyCounterValues(t)
68 //-----------------------------------------------------------------------------
69 // TestRESTSubReqAfterE2ConnBreak
72 // +-------+ +---------+ +---------+
73 // | xapp | | submgr | | e2term |
74 // +-------+ +---------+ +---------+
76 // | [E2 Conn. DOWN] |
79 // |---------------->| |
81 // |<----------------| |
84 //-----------------------------------------------------------------------------
86 func TestRESTSubReqAfterE2ConnBreak(t *testing.T) {
87 CaseBegin("TestRESTSubReqAfterE2ConnBreak")
89 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
90 Counter{cRestSubReqFromXapp, 1},
91 Counter{cRestReqRejDueE2Down, 1},
92 Counter{cE2StateChangedToDown, 1},
93 Counter{cE2StateChangedToUp, 1},
96 // E2 disconnect after E2term has received response
97 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
99 const subReqCount int = 1
100 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
101 xappConn1.SendRESTSubsReq(t, params)
103 // Restore E2 connection for following test cases
104 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
106 mainCtrl.VerifyAllClean(t)
107 mainCtrl.VerifyCounterValues(t)
111 //-----------------------------------------------------------------------------
112 // TestRESTSubReqE2ConnBreak
115 // +-------+ +---------+ +---------+
116 // | xapp | | submgr | | e2term |
117 // +-------+ +---------+ +---------+
120 // |---------------->| |
122 // |<----------------| |
124 // | |------------->|
126 // | |<-------------|
128 // | [E2 Conn. DOWN] |
129 // | [Int. SUBS DELETE] |
131 // | RESTNotif(unsuccessful) |
132 // |<----------------| |
136 //-----------------------------------------------------------------------------
137 func TestRESTSubReqE2ConnBreak(t *testing.T) {
138 CaseBegin("TestRESTSubReqE2ConnBreak")
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 // | |------------->|
2674 // | | RouteCreate |
2676 // | |(Bad request) |
2677 // | |<-------------|
2679 // |<----------------| |
2681 // | [SUBS INT DELETE] |
2683 // | RESTSubDelReq | |
2684 // |---------------->| |
2685 // | RESTSubDelResp | |
2686 // |<----------------| |
2688 //-----------------------------------------------------------------------------
2689 func TestRESTSubReqAndRouteNok(t *testing.T) {
2690 CaseBegin("TestRESTSubReqAndRouteNok")
2692 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2693 Counter{cRestSubReqFromXapp, 1},
2694 Counter{cRestSubRespToXapp, 1},
2695 Counter{cRouteCreateFail, 1},
2696 Counter{cRestSubFailNotifToXapp, 1},
2697 Counter{cRestSubDelReqFromXapp, 1},
2698 Counter{cRestSubDelRespToXapp, 1},
2701 const subReqCount int = 1
2703 // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
2704 waiter := rtmgrHttp.AllocNextSleep(50, false)
2705 newSubsId := mainCtrl.get_registry_next_subid(t)
2708 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2709 restSubId := xappConn1.SendRESTSubsReq(t, params)
2710 xappConn1.ExpectRESTNotificationNok(t, restSubId, "failAll")
2711 waiter.WaitResult(t)
2713 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2714 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
2717 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2719 // Wait that subs is cleaned
2720 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2721 waitSubsCleanup(t, e2SubsId, 10)
2722 mainCtrl.VerifyCounterValues(t)
2723 mainCtrl.VerifyAllClean(t)
2726 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
2727 CaseBegin("TestSubReqAndRouteUpdateNok")
2729 //Init counter check
2730 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2731 Counter{cRestSubReqFromXapp, 2},
2732 Counter{cRestSubRespToXapp, 2},
2733 Counter{cSubReqToE2, 1},
2734 Counter{cSubRespFromE2, 1},
2735 Counter{cRestSubNotifToXapp, 1},
2736 Counter{cRestSubFailNotifToXapp, 1},
2737 Counter{cRouteCreateUpdateFail, 1},
2738 Counter{cRestSubDelReqFromXapp, 2},
2739 Counter{cSubDelReqToE2, 1},
2740 Counter{cSubDelRespFromE2, 1},
2741 Counter{cRestSubDelRespToXapp, 2},
2744 var params *teststube2ap.RESTSubsReqParams = nil
2747 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2749 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2751 // xapp2 ROUTE creation shall fail with 400 from rtmgr -> submgr
2752 waiter := rtmgrHttp.AllocNextEvent(false)
2753 newSubsId := mainCtrl.get_registry_next_subid(t)
2754 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
2755 params.SetMeid("RAN_NAME_1")
2756 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2757 xapp.Logger.Debug("Send REST subscriber request for second subscriber : %v", restSubId2)
2758 xappConn2.ExpectRESTNotificationNok(t, restSubId2, "allFail")
2759 waiter.WaitResult(t)
2760 xappConn2.WaitRESTNotification(t, restSubId2)
2762 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2764 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2765 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
2767 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2768 //Wait that subs is cleaned
2769 waitSubsCleanup(t, e2SubsId, 10)
2771 mainCtrl.VerifyCounterValues(t)
2772 mainCtrl.VerifyAllClean(t)
2775 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
2776 CaseBegin("TestRESTSubDelReqAndRouteDeleteNok")
2778 // Init counter check
2779 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2780 Counter{cRestSubReqFromXapp, 1},
2781 Counter{cRestSubRespToXapp, 1},
2782 Counter{cSubReqToE2, 1},
2783 Counter{cSubRespFromE2, 1},
2784 Counter{cRestSubNotifToXapp, 1},
2785 Counter{cRestSubDelReqFromXapp, 1},
2786 Counter{cRouteDeleteFail, 1},
2787 Counter{cSubDelReqToE2, 1},
2788 Counter{cSubDelRespFromE2, 1},
2789 Counter{cRestSubDelRespToXapp, 1},
2792 var params *teststube2ap.RESTSubsReqParams = nil
2795 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2797 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2799 waiter := rtmgrHttp.AllocNextEvent(false)
2800 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2801 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2802 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2803 waiter.WaitResult(t)
2805 waitSubsCleanup(t, e2SubsId, 10)
2806 mainCtrl.VerifyCounterValues(t)
2807 mainCtrl.VerifyAllClean(t)
2810 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
2811 CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok")
2813 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2814 Counter{cRestSubReqFromXapp, 2},
2815 Counter{cMergedSubscriptions, 1},
2816 Counter{cRestSubRespToXapp, 2},
2817 Counter{cSubReqToE2, 1},
2818 Counter{cSubRespFromE2, 1},
2819 Counter{cRestSubNotifToXapp, 2},
2820 Counter{cRestSubDelReqFromXapp, 2},
2821 Counter{cRouteDeleteUpdateFail, 1},
2822 Counter{cSubDelReqToE2, 1},
2823 Counter{cSubDelRespFromE2, 1},
2824 Counter{cRestSubDelRespToXapp, 2},
2825 Counter{cUnmergedSubscriptions, 1},
2828 var params *teststube2ap.RESTSubsReqParams = nil
2831 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2833 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2834 restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1")
2836 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
2838 //Del1, this shall fail on rtmgr side
2839 waiter := rtmgrHttp.AllocNextEvent(false)
2840 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2841 waiter.WaitResult(t)
2843 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"})
2846 deleteXapp2Subscription(t, &restSubId2)
2848 waitSubsCleanup(t, e2SubsId2, 10)
2849 mainCtrl.VerifyCounterValues(t)
2850 mainCtrl.VerifyAllClean(t)
2853 //-----------------------------------------------------------------------------
2854 // TestRESTSubReqRetransmission
2857 // +-------+ +---------+ +---------+
2858 // | xapp | | submgr | | e2term |
2859 // +-------+ +---------+ +---------+
2861 // | RESTSubReq1 | |
2862 // |---------------->| |
2864 // | RESTSubResp | |
2865 // |<----------------| |
2867 // | |------------->|
2869 // | RESTSubReq2 | |
2871 // |---------------->| |
2872 // | RESTSubResp(201)| |
2873 // |<----------------| |
2876 // | |<-------------|
2878 // |<----------------| |
2880 // | [SUBS DELETE] |
2883 //-----------------------------------------------------------------------------
2885 func TestRESTSubReqRetransmission(t *testing.T) {
2886 CaseBegin("TestRESTSubReqRetransmission")
2888 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2889 Counter{cRestSubReqFromXapp, 2},
2890 Counter{cRestSubRespToXapp, 2},
2891 Counter{cSubReqToE2, 1},
2892 Counter{cSubRespFromE2, 1},
2893 Counter{cRestSubNotifToXapp, 1},
2894 Counter{cRestSubDelReqFromXapp, 1},
2895 Counter{cSubDelReqToE2, 1},
2896 Counter{cSubDelRespFromE2, 1},
2897 Counter{cRestSubDelRespToXapp, 1},
2899 // Retry/duplicate will get the same way as the first request.
2900 // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
2901 // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
2904 const subReqCount int = 1
2906 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2907 restSubId := xappConn1.SendRESTSubsReq(t, params)
2909 xappConn1.SendRESTSubsReq(t, params)
2910 <-time.After(time.Second * 1)
2912 xappConn1.WaitListedRestNotifications(t, []string{restSubId})
2914 // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
2915 // the order is not significant here.
2916 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2917 e2termConn1.SendSubsResp(t, crereq, cremsg)
2919 e2SubsId := <-xappConn1.ListedRESTNotifications
2921 xapp.Logger.Debug("TEST: XAPP notification received e2SubsId=%v", e2SubsId)
2924 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2925 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2926 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2928 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsId.E2SubsId}, 10)
2930 mainCtrl.VerifyCounterValues(t)
2931 mainCtrl.VerifyAllClean(t)
2934 //-----------------------------------------------------------------------------
2936 // +-------+ +---------+ +---------+ +---------+
2937 // | xapp | | submgr | | e2term | | rtmgr |
2938 // +-------+ +---------+ +---------+ +---------+
2940 // | RESTSubReq | | |
2941 // |---------------->| | |
2942 // | RESTSubResp | | |
2943 // |<----------------| | |
2944 // | | RouteCreate | |
2945 // | |--------------------------->|
2946 // | | RouteResponse| |
2947 // | |<---------------------------| // The order of these events may vary
2949 // | |------------->| | // The order of these events may vary
2951 // | |<-------------| |
2952 // | RESTNotif1 | | |
2953 // |<----------------| | |
2954 // | RESTSubReq | | |
2955 // | [RETRANS1] | | |
2956 // |---------------->| | |
2957 // | RESTNotif1 | | |
2958 // |<----------------| | |
2959 // | RESTSubReq | | |
2960 // | [RETRANS2] | | |
2961 // |---------------->| | |
2962 // | RESTNotif1 | | |
2963 // |<----------------| | |
2964 // | RESTSubDelReq | | |
2965 // |---------------->| | |
2966 // | | SubDelReq | |
2967 // | |------------->| |
2968 // | RESTSubDelResp| | |
2969 // |<----------------| | |
2970 // | | SubDelResp | |
2971 // | |<-------------| |
2974 //-----------------------------------------------------------------------------
2976 func TestRESTSubReqRetransmissionV2(t *testing.T) {
2977 CaseBegin("TestRESTSubReqRetransmissionV2")
2979 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2980 Counter{cRestSubReqFromXapp, 3},
2981 Counter{cDuplicateE2SubReq, 2},
2982 Counter{cRestSubRespToXapp, 3},
2983 Counter{cSubReqToE2, 1},
2984 Counter{cSubRespFromE2, 1},
2985 Counter{cRestSubNotifToXapp, 3},
2986 Counter{cRestSubDelReqFromXapp, 1},
2987 Counter{cSubDelReqToE2, 1},
2988 Counter{cSubDelRespFromE2, 1},
2989 Counter{cRestSubDelRespToXapp, 1},
2992 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2994 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2996 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2998 mainCtrl.WaitOngoingRequestMapEmpty()
3001 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
3003 assert.Equal(t, restSubId_resend, restSubId)
3005 mainCtrl.WaitOngoingRequestMapEmpty()
3008 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3010 assert.Equal(t, restSubId_resend2, restSubId)
3012 mainCtrl.WaitOngoingRequestMapEmpty()
3014 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3016 waitSubsCleanup(t, e2SubsId, 10)
3017 mainCtrl.VerifyCounterValues(t)
3018 mainCtrl.VerifyAllClean(t)
3021 //-----------------------------------------------------------------------------
3023 // +-------+ +---------+ +---------+ +---------+
3024 // | xapp | | submgr | | e2term | | rtmgr |
3025 // +-------+ +---------+ +---------+ +---------+
3027 // | RESTSubReq | | |
3028 // |---------------->| | |
3029 // | RESTSubResp | | |
3030 // |<----------------| | |
3031 // | | RouteCreate | |
3032 // | |--------------------------->|
3033 // | | RouteResponse| |
3034 // | |<---------------------------| // The order of these events may vary
3036 // | |------------->| | // The order of these events may vary
3038 // | |<-------------| |
3039 // | RESTNotif1 | | |
3040 // |<----------------| | |
3041 // | RESTSubReq | | |
3042 // | [RETRANS, with RESTsubsId] | |
3043 // |---------------->| | |
3044 // | RESTNotif1 | | |
3045 // |<----------------| | |
3046 // | RESTSubReq | | |
3047 // | [RETRANS, without RESTsubsId] | |
3048 // |---------------->| | |
3049 // | RESTNotif1 | | |
3050 // |<----------------| | |
3051 // | RESTSubDelReq | | |
3052 // |---------------->| | |
3053 // | | SubDelReq | |
3054 // | |------------->| |
3055 // | RESTSubDelResp| | |
3056 // |<----------------| | |
3057 // | | SubDelResp | |
3058 // | |<-------------| |
3061 //-----------------------------------------------------------------------------
3062 func TestRESTSubReqRetransmissionV3(t *testing.T) {
3063 CaseBegin("TestRESTSubReqRetransmissionV3")
3065 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3066 Counter{cRestSubReqFromXapp, 3},
3067 Counter{cDuplicateE2SubReq, 2},
3068 Counter{cRestSubRespToXapp, 3},
3069 Counter{cSubReqToE2, 1},
3070 Counter{cSubRespFromE2, 1},
3071 Counter{cRestSubNotifToXapp, 3},
3072 Counter{cRestSubDelReqFromXapp, 1},
3073 Counter{cSubDelReqToE2, 1},
3074 Counter{cSubDelRespFromE2, 1},
3075 Counter{cRestSubDelRespToXapp, 1},
3078 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3080 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3082 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3084 mainCtrl.WaitOngoingRequestMapEmpty()
3086 //1.st resend with subscription ID
3087 params.SetSubscriptionID(&restSubId)
3088 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
3090 assert.Equal(t, restSubId_resend, restSubId)
3092 mainCtrl.WaitOngoingRequestMapEmpty()
3094 //2.nd resend without subscription ID (faking app restart)
3095 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3096 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3098 assert.Equal(t, restSubId_resend2, restSubId)
3100 mainCtrl.WaitOngoingRequestMapEmpty()
3102 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3104 waitSubsCleanup(t, e2SubsId, 10)
3105 mainCtrl.VerifyCounterValues(t)
3106 mainCtrl.VerifyAllClean(t)
3109 //-----------------------------------------------------------------------------
3111 // +-------+ +---------+ +---------+ +---------+
3112 // | xapp | | submgr | | e2term | | rtmgr |
3113 // +-------+ +---------+ +---------+ +---------+
3115 // | RESTSubReq | | |
3116 // |---------------->| | |
3117 // | RESTSubResp | | |
3118 // |<----------------| | |
3119 // | | RouteCreate | |
3120 // | |--------------------------->|
3121 // | | RouteResponse| |
3122 // | |<---------------------------|
3124 // | |------------->| |
3126 // | |<-------------| |
3127 // | RESTNotif1 | | |
3128 // |<----------------| | |
3129 // | RESTSubReq | | |
3130 // | [with RestSUbsId + one additional e2 subDetail]
3131 // |---------------->| | |
3132 // | RESTNotif1 | | |
3133 // | [for initial e2 subDetail] | |
3134 // |<----------------| | |
3135 // | | RouteCreate | |
3136 // | |--------------------------->|
3137 // | | RouteResponse| |
3138 // | |<---------------------------|
3140 // | |------------->| |
3142 // | |<-------------| |
3143 // | RESTNotif1 | | |
3144 // |<----------------| | |
3145 // | RESTSubReq | | |
3146 // | [with RESTsubsId initial request] |
3147 // |---------------->| | |
3148 // | RESTNotif1 | | |
3149 // |<----------------| | |
3150 // | RESTSubDelReq | | |
3151 // |---------------->| | |
3152 // | RESTSubDelResp| | |
3153 // |<----------------| | |
3154 // | | SubDelReq | |
3155 // | |------------->| |
3156 // | | SubDelResp | |
3157 // | |<-------------| |
3158 // | | SubDelReq | |
3159 // | |------------->| |
3160 // | | SubDelResp | |
3161 // | |<-------------| |
3164 //-----------------------------------------------------------------------------
3166 func TestRESTSubReqRetransmissionV4(t *testing.T) {
3167 CaseBegin("TestRESTSubReqRetransmissionV4")
3169 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3170 Counter{cRestSubReqFromXapp, 3},
3171 Counter{cDuplicateE2SubReq, 2},
3172 Counter{cRestSubRespToXapp, 3},
3173 Counter{cSubReqToE2, 2},
3174 Counter{cSubRespFromE2, 2},
3175 Counter{cRestSubNotifToXapp, 4},
3176 Counter{cRestSubDelReqFromXapp, 1},
3177 Counter{cSubDelReqToE2, 2},
3178 Counter{cSubDelRespFromE2, 2},
3179 Counter{cRestSubDelRespToXapp, 1},
3182 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3184 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3186 mainCtrl.WaitOngoingRequestMapEmpty()
3188 // Send modified requst, this time with e2 subscriptions.
3189 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3190 params2.SetSubscriptionID(&restSubId)
3192 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3193 xappConn1.ExpectAnyNotification(t)
3194 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3195 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3196 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3197 assert.Equal(t, e2SubsId, e2SubsId1)
3199 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3201 xappConn1.DecrementRequestCount()
3202 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3203 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3204 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3205 assert.NotEqual(t, e2SubsId2, 0)
3207 mainCtrl.WaitOngoingRequestMapEmpty()
3209 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3210 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3211 params.SetSubscriptionID(&restSubId)
3212 xappConn1.ExpectAnyNotification(t)
3213 // Resend the original request again with only one e2 subscription (detail), this time with restsubsid
3214 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3215 assert.Equal(t, restSubId_resend, restSubId_resend2)
3217 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3218 assert.Equal(t, e2SubsId, e2SubsId1)
3220 mainCtrl.WaitOngoingRequestMapEmpty()
3222 // Delete both e2 subscriptions
3223 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3224 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3225 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3227 waitSubsCleanup(t, e2SubsId, 10)
3228 mainCtrl.VerifyCounterValues(t)
3229 mainCtrl.VerifyAllClean(t)
3232 //-----------------------------------------------------------------------------
3234 // +-------+ +---------+ +---------+ +---------+
3235 // | xapp | | submgr | | e2term | | rtmgr |
3236 // +-------+ +---------+ +---------+ +---------+
3238 // | RESTSubReq | | |
3239 // |---------------->| | |
3240 // | RESTSubResp | | |
3241 // |<----------------| | |
3242 // | | RouteCreate | |
3243 // | |--------------------------->|
3244 // | | RouteResponse| |
3245 // | |<---------------------------|
3247 // | |------------->| |
3249 // | |<-------------| |
3250 // | RESTNotif1 | | |
3251 // |<----------------| | |
3252 // | RESTSubReq | | |
3253 // | [with RestSUbsId + one additional e2 subDetail]
3254 // |---------------->| | |
3255 // | RESTNotif1 | | |
3256 // | [for initial e2 subDetail] | |
3257 // |<----------------| | |
3258 // | | RouteCreate | |
3259 // | |--------------------------->|
3260 // | | RouteResponse| |
3261 // | |<---------------------------|
3263 // | |------------->| |
3265 // | |<-------------| |
3266 // | RESTNotif1 | | |
3267 // |<----------------| | |
3268 // | RESTSubReq | | |
3269 // | [without RESTsubsId initial request] |
3270 // |---------------->| | |
3271 // | RESTNotif1 | | |
3272 // |<----------------| | |
3273 // | RESTSubDelReq | | |
3274 // |---------------->| | |
3275 // | RESTSubDelResp| | |
3276 // |<----------------| | |
3277 // | | SubDelReq | |
3278 // | |------------->| |
3279 // | | SubDelResp | |
3280 // | |<-------------| |
3281 // | | SubDelReq | |
3282 // | |------------->| |
3283 // | | SubDelResp | |
3284 // | |<-------------| |
3287 //-----------------------------------------------------------------------------
3289 func TestRESTSubReqRetransmissionV5(t *testing.T) {
3290 CaseBegin("TestRESTSubReqRetransmissionV5")
3292 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3293 Counter{cRestSubReqFromXapp, 3},
3294 Counter{cDuplicateE2SubReq, 2},
3295 Counter{cRestSubRespToXapp, 3},
3296 Counter{cSubReqToE2, 2},
3297 Counter{cSubRespFromE2, 2},
3298 Counter{cRestSubNotifToXapp, 4},
3299 Counter{cRestSubDelReqFromXapp, 1},
3300 Counter{cSubDelReqToE2, 2},
3301 Counter{cSubDelRespFromE2, 2},
3302 Counter{cRestSubDelRespToXapp, 1},
3305 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3307 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3309 mainCtrl.WaitOngoingRequestMapEmpty()
3311 // Send modified request, this time with e2 subscriptions.
3312 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3313 params2.SetSubscriptionID(&restSubId)
3315 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3316 xappConn1.ExpectAnyNotification(t)
3317 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3318 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3320 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3321 assert.Equal(t, e2SubsId, e2SubsId1)
3322 // The first E2 subscription returns immediately, manually decrement expected request count for the remaining request handling
3323 xappConn1.DecrementRequestCount()
3325 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3327 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3328 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3329 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3330 assert.NotEqual(t, e2SubsId2, 0)
3332 mainCtrl.WaitOngoingRequestMapEmpty()
3334 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3335 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3336 xappConn1.ExpectAnyNotification(t)
3337 // Resend the original request again with only one e2 subscription (detail), WITHOUT restsubsid
3338 // md5sum shall find the original request
3339 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3340 assert.Equal(t, restSubId_resend, restSubId_resend2)
3342 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3343 assert.Equal(t, e2SubsId, e2SubsId1)
3345 mainCtrl.WaitOngoingRequestMapEmpty()
3347 // Delete both e2 subscriptions
3348 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3349 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3350 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3352 waitSubsCleanup(t, e2SubsId, 10)
3353 mainCtrl.VerifyCounterValues(t)
3354 mainCtrl.VerifyAllClean(t)
3357 //-----------------------------------------------------------------------------
3359 // +-------+ +---------+ +---------+ +---------+
3360 // | xapp | | submgr | | e2term | | rtmgr |
3361 // +-------+ +---------+ +---------+ +---------+
3363 // | RESTSubReq | | |
3364 // |---------------->| | |
3365 // | RESTSubResp | | |
3366 // |<----------------| | |
3367 // | | RouteCreate | |
3368 // | |--------------------------->|
3369 // | | RouteResponse| |
3370 // | |<---------------------------|
3372 // | |------------->| |
3374 // | |<-------------| |
3375 // | RESTNotif1 | | |
3376 // |<----------------| | |
3377 // | RESTSubReq | | |
3378 // | [with RestSUbsId + one additional e2 subDetail]
3379 // |---------------->| | |
3380 // | RESTNotif1 | | |
3381 // | [for initial e2 subDetail] | |
3382 // |<----------------| | |
3383 // | | RouteCreate | |
3384 // | |--------------------------->|
3385 // | | RouteResponse| |
3386 // | |<---------------------------|
3388 // | |------------->| |
3390 // | |<-------------| |
3391 // | RESTNotif1 | | |
3392 // |<----------------| | |
3393 // | RESTSubDelReq | | |
3394 // |---------------->| | |
3395 // | RESTSubDelResp| | |
3396 // |<----------------| | |
3397 // | | SubDelReq | |
3398 // | |------------->| |
3399 // | | SubDelResp | |
3400 // | |<-------------| |
3401 // | | SubDelReq | |
3402 // | |------------->| |
3403 // | | SubDelResp | |
3404 // | |<-------------| |
3405 // | RESTSubReq | | |
3406 // | [with RESTsubsId initial request] |
3407 // |---------------->| | |
3408 // | RESTSubResp | | |
3409 // |<----------------| | |
3410 // | | RouteCreate | |
3411 // | |--------------------------->|
3412 // | | RouteResponse| |
3413 // | |<---------------------------|
3415 // | |------------->| |
3417 // | |<-------------| |
3418 // | RESTNotif1 | | |
3419 // |<----------------| | |
3422 //-----------------------------------------------------------------------------
3423 func TestRESTSubReqRetransmissionV6(t *testing.T) {
3424 CaseBegin("TestRESTSubReqRetransmissionV6")
3426 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3427 Counter{cRestSubReqFromXapp, 3},
3428 Counter{cDuplicateE2SubReq, 1},
3429 Counter{cRestSubRespToXapp, 3},
3430 Counter{cSubReqToE2, 3},
3431 Counter{cSubRespFromE2, 3},
3432 Counter{cRestSubNotifToXapp, 4},
3433 Counter{cRestSubDelReqFromXapp, 2},
3434 Counter{cSubDelReqToE2, 3},
3435 Counter{cSubDelRespFromE2, 3},
3436 Counter{cRestSubDelRespToXapp, 2},
3439 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3441 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3443 mainCtrl.WaitOngoingRequestMapEmpty()
3445 // Send modified requst, this time with e2 subscriptions.
3446 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3447 params2.SetSubscriptionID(&restSubId)
3449 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3450 xappConn1.ExpectAnyNotification(t)
3451 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3452 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3454 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3455 assert.Equal(t, e2SubsId, e2SubsId1)
3457 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3459 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3460 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3461 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3462 assert.NotEqual(t, e2SubsId2, 0)
3464 mainCtrl.WaitOngoingRequestMapEmpty()
3466 // Delete both e2 subscriptions
3467 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3468 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3469 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3471 waitSubsCleanup(t, e2SubsId, 10)
3473 // Resend the original request, we shall find it's previous md5sum/restsubs
3474 // but the restsubscription has been already removed. This shall trigger a
3476 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
3478 mainCtrl.WaitOngoingRequestMapEmpty()
3480 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3482 waitSubsCleanup(t, e2SubsId, 10)
3483 mainCtrl.VerifyCounterValues(t)
3484 mainCtrl.VerifyAllClean(t)
3487 func TestRESTSubDelReqRetransmission(t *testing.T) {
3488 CaseBegin("TestRESTSubDelReqRetransmission")
3490 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3491 Counter{cRestSubReqFromXapp, 1},
3492 Counter{cRestSubRespToXapp, 1},
3493 Counter{cSubReqToE2, 1},
3494 Counter{cSubRespFromE2, 1},
3495 Counter{cRestSubNotifToXapp, 1},
3496 Counter{cRestSubDelReqFromXapp, 2},
3497 Counter{cSubDelReqToE2, 1},
3498 Counter{cSubDelRespFromE2, 1},
3499 Counter{cRestSubDelRespToXapp, 2},
3502 var params *teststube2ap.RESTSubsReqParams = nil
3505 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3507 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3510 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3511 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3513 seqBef := mainCtrl.get_msgcounter(t)
3514 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3515 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
3517 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3519 waitSubsCleanup(t, e2SubsId, 10)
3520 mainCtrl.VerifyCounterValues(t)
3521 mainCtrl.VerifyAllClean(t)
3524 //-----------------------------------------------------------------------------
3525 // TestRESTSubReqDelReq
3528 // +-------+ +---------+ +---------+
3529 // | xapp | | submgr | | e2term |
3530 // +-------+ +---------+ +---------+
3533 // |---------------->| |
3535 // | RESTSubResp | |
3536 // |<----------------| |
3538 // | |------------->|
3539 // | RESTSubDelReq | |
3540 // |---------------->| |
3541 // | RESTSubDelResp | |
3543 // |<----------------| |
3545 // | |<-------------|
3547 // |<----------------| |
3549 // | [SUBS DELETE] |
3552 //-----------------------------------------------------------------------------
3553 func TestRESTSubReqDelReq(t *testing.T) {
3554 CaseBegin("TestRESTSubReqDelReq")
3556 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3557 Counter{cRestSubReqFromXapp, 1},
3558 Counter{cRestSubRespToXapp, 1},
3559 Counter{cSubReqToE2, 1},
3560 Counter{cSubRespFromE2, 1},
3561 Counter{cRestSubNotifToXapp, 1},
3562 Counter{cRestSubDelReqFromXapp, 2},
3563 Counter{cRestSubDelFailToXapp, 1},
3564 Counter{cSubDelReqToE2, 1},
3565 Counter{cSubDelRespFromE2, 1},
3566 Counter{cRestSubDelRespToXapp, 1},
3569 const subReqCount int = 1
3572 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3573 restSubId := xappConn1.SendRESTSubsReq(t, params)
3575 // Del. This will fail as processing of the subscription
3576 // is still ongoing in submgr. Deletion is not allowed before
3577 // subscription creation has been completed.
3578 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3579 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3580 xappConn1.ExpectRESTNotification(t, restSubId)
3581 e2termConn1.SendSubsResp(t, crereq, cremsg)
3582 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3585 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3587 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3588 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3590 // Wait that subs is cleaned
3591 waitSubsCleanup(t, e2SubsId, 10)
3592 mainCtrl.VerifyCounterValues(t)
3593 mainCtrl.VerifyAllClean(t)
3596 func TestRESTSubDelReqCollision(t *testing.T) {
3597 CaseBegin("TestRESTSubDelReqCollision - not relevant for REST API")
3600 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
3601 CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel")
3603 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3604 Counter{cRestSubReqFromXapp, 2},
3605 Counter{cRestSubRespToXapp, 2},
3606 Counter{cSubReqToE2, 2},
3607 Counter{cSubRespFromE2, 2},
3608 Counter{cRestSubNotifToXapp, 2},
3609 Counter{cRestSubDelReqFromXapp, 2},
3610 Counter{cSubDelReqToE2, 2},
3611 Counter{cSubDelRespFromE2, 2},
3612 Counter{cRestSubDelRespToXapp, 2},
3616 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3617 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3618 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3621 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3622 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3623 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3625 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3626 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3628 //XappConn1 receives both of the responses
3629 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3632 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3634 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3636 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3637 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3638 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3639 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3642 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3644 deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
3646 //Wait that subs is cleaned
3647 mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
3648 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
3650 mainCtrl.VerifyCounterValues(t)
3651 mainCtrl.VerifyAllClean(t)
3654 func TestRESTSameSubsDiffRan(t *testing.T) {
3655 CaseBegin("TestRESTSameSubsDiffRan")
3657 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3658 Counter{cRestSubReqFromXapp, 2},
3659 Counter{cRestSubRespToXapp, 2},
3660 Counter{cSubReqToE2, 2},
3661 Counter{cSubRespFromE2, 2},
3662 Counter{cRestSubNotifToXapp, 2},
3663 Counter{cRestSubDelReqFromXapp, 2},
3664 Counter{cSubDelReqToE2, 2},
3665 Counter{cSubDelRespFromE2, 2},
3666 Counter{cRestSubDelRespToXapp, 2},
3669 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3670 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3671 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3673 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3674 params.SetMeid("RAN_NAME_2")
3675 restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
3676 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3679 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3681 deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
3683 //Wait that subs is cleaned
3684 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3685 waitSubsCleanup(t, e2SubsId2, 10)
3687 mainCtrl.VerifyCounterValues(t)
3688 mainCtrl.VerifyAllClean(t)
3691 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
3692 CaseBegin("TestRESTSubReqRetryInSubmgr start")
3694 // Init counter check
3695 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3696 Counter{cRestSubReqFromXapp, 1},
3697 Counter{cRestSubRespToXapp, 1},
3698 Counter{cSubReqToE2, 1},
3699 Counter{cSubReqTimerExpiry, 1},
3700 Counter{cSubReReqToE2, 1},
3701 Counter{cSubRespFromE2, 1},
3702 Counter{cRestSubNotifToXapp, 1},
3703 Counter{cRestSubDelReqFromXapp, 1},
3704 Counter{cSubDelReqToE2, 1},
3705 Counter{cSubDelRespFromE2, 1},
3706 Counter{cRestSubDelRespToXapp, 1},
3709 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3710 restSubId := xappConn1.SendRESTSubsReq(t, params)
3712 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3714 // Catch the first message and ignore it
3715 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3716 xapp.Logger.Debug("Ignore REST subscriber request for subscriber : %v", restSubId)
3718 // The second request is being handled normally
3719 crereq, cremsg = e2termConn1.RecvSubsReq(t)
3720 xappConn1.ExpectRESTNotification(t, restSubId)
3721 e2termConn1.SendSubsResp(t, crereq, cremsg)
3722 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3724 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3726 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3728 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
3729 //Wait that subs is cleaned
3730 waitSubsCleanup(t, e2SubsId, 10)
3732 mainCtrl.VerifyCounterValues(t)
3733 mainCtrl.VerifyAllClean(t)
3736 //-----------------------------------------------------------------------------
3737 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3740 // +-------+ +---------+ +---------+
3741 // | xapp | | submgr | | e2term |
3742 // +-------+ +---------+ +---------+
3745 // |---------------->| |
3747 // | RESTSubResp | |
3748 // |<----------------| |
3750 // | |------------->|
3754 // | |------------->|
3757 // | |------------->|
3761 // | |------------->|
3765 // | |<-------------|
3768 // |<----------------| |
3770 // | [SUBS DELETE] |
3773 //-----------------------------------------------------------------------------
3775 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
3776 CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
3778 // Init counter check
3779 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3780 Counter{cRestSubReqFromXapp, 1},
3781 Counter{cRestSubRespToXapp, 1},
3782 Counter{cSubReqToE2, 1},
3783 Counter{cSubReReqToE2, 1},
3784 Counter{cSubReqTimerExpiry, 2},
3785 Counter{cRestSubFailNotifToXapp, 1},
3786 Counter{cSubDelReqToE2, 1},
3787 Counter{cSubDelRespFromE2, 1},
3788 Counter{cRestSubDelReqFromXapp, 1},
3789 Counter{cRestSubDelRespToXapp, 1},
3792 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3793 restSubId := xappConn1.SendRESTSubsReq(t, params)
3794 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3796 e2termConn1.RecvSubsReq(t)
3797 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3799 e2termConn1.RecvSubsReq(t)
3800 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3802 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3803 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3804 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3805 xappConn1.WaitRESTNotification(t, restSubId)
3807 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3809 // Wait that subs is cleaned
3810 waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
3811 mainCtrl.VerifyCounterValues(t)
3812 mainCtrl.VerifyAllClean(t)
3815 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
3816 CaseBegin("TestREST2eTermNotRespondingToSubReq start")
3818 // Init counter check
3819 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3820 Counter{cRestSubReqFromXapp, 1},
3821 Counter{cRestSubRespToXapp, 1},
3822 Counter{cSubReqToE2, 1},
3823 Counter{cSubReReqToE2, 1},
3824 Counter{cSubReqTimerExpiry, 2},
3825 Counter{cSubDelReReqToE2, 1},
3826 Counter{cRestSubFailNotifToXapp, 1},
3827 Counter{cSubDelReqToE2, 1},
3828 Counter{cSubDelReqTimerExpiry, 2},
3829 Counter{cRestSubDelReqFromXapp, 1},
3830 Counter{cRestSubDelRespToXapp, 1},
3833 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3834 restSubId := xappConn1.SendRESTSubsReq(t, params)
3835 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3837 e2termConn1.RecvSubsReq(t)
3838 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3840 e2termConn1.RecvSubsReq(t)
3841 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3843 e2termConn1.RecvSubsDelReq(t)
3844 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3846 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3847 e2termConn1.RecvSubsDelReq(t)
3848 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3850 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3852 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3854 waitSubsCleanup(t, e2SubsId, 10)
3855 mainCtrl.VerifyCounterValues(t)
3856 mainCtrl.VerifyAllClean(t)
3859 //-----------------------------------------------------------------------------
3860 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3863 // +-------+ +---------+ +---------+
3864 // | xapp | | submgr | | e2term |
3865 // +-------+ +---------+ +---------+
3868 // |---------------->| |
3870 // | RESTSubResp | |
3871 // |<----------------| |
3873 // | |------------->|
3877 // | |------------->|
3880 // | |------------->|
3884 // | |------------->|
3888 // | |<-------------|
3891 // |<----------------| |
3893 // | [SUBS DELETE] |
3896 //-----------------------------------------------------------------------------
3897 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
3898 CaseBegin("TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr start")
3900 // Init counter check
3901 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3902 Counter{cRestSubReqFromXapp, 1},
3903 Counter{cRestSubRespToXapp, 1},
3904 Counter{cSubReqToE2, 1},
3905 Counter{cSubReReqToE2, 1},
3906 Counter{cSubReqTimerExpiry, 2},
3907 Counter{cRestSubFailNotifToXapp, 1},
3908 Counter{cSubDelReqToE2, 1},
3909 Counter{cSubDelReReqToE2, 1},
3910 Counter{cSubDelReqTimerExpiry, 2},
3911 Counter{cRestSubDelReqFromXapp, 1},
3912 Counter{cRestSubDelRespToXapp, 1},
3915 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3916 restSubId := xappConn1.SendRESTSubsReq(t, params)
3917 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3919 e2termConn1.RecvSubsReq(t)
3920 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3922 e2termConn1.RecvSubsReq(t)
3923 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3925 e2termConn1.RecvSubsDelReq(t)
3926 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3928 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3929 e2termConn1.RecvSubsDelReq(t)
3930 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3932 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3934 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3936 waitSubsCleanup(t, e2SubsId, 10)
3937 mainCtrl.VerifyCounterValues(t)
3938 mainCtrl.VerifyAllClean(t)
3941 //-----------------------------------------------------------------------------
3942 // TestRESTSubReqSubFailRespInSubmgr
3945 // +-------+ +---------+ +---------+
3946 // | xapp | | submgr | | e2term |
3947 // +-------+ +---------+ +---------+
3950 // |---------------->| |
3952 // | RESTSubResp | |
3953 // |<----------------| |
3955 // | |------------->|
3958 // | |<-------------|
3962 // |<----------------| |
3964 // | [SUBS DELETE] |
3967 //-----------------------------------------------------------------------------
3968 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
3969 CaseBegin("TestRESTSubReqSubFailRespInSubmgr")
3971 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3972 Counter{cRestSubReqFromXapp, 1},
3973 Counter{cRestSubRespToXapp, 1},
3974 Counter{cSubReqToE2, 1},
3975 Counter{cSubFailFromE2, 1},
3976 Counter{cRestSubFailNotifToXapp, 1},
3977 Counter{cRestSubDelReqFromXapp, 1},
3978 Counter{cRestSubDelRespToXapp, 1},
3981 const subReqCount int = 1
3982 const e2Timeout int64 = 2
3983 const e2RetryCount int64 = 1
3984 const routingNeeded bool = true
3986 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3987 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
3988 restSubId := xappConn1.SendRESTSubsReq(t, params)
3990 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3991 fparams1 := &teststube2ap.E2StubSubsFailParams{}
3992 fparams1.Set(crereq1)
3993 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3994 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3996 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3997 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
3999 // REST subscription sill there to be deleted
4000 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4002 // Wait that subs is cleaned
4003 waitSubsCleanup(t, e2SubsId, 10)
4005 mainCtrl.VerifyCounterValues(t)
4006 mainCtrl.VerifyAllClean(t)
4009 //-----------------------------------------------------------------------------
4010 // TestRESTSubDelReqRetryInSubmgr
4013 // +-------+ +---------+ +---------+
4014 // | xapp | | submgr | | e2term |
4015 // +-------+ +---------+ +---------+
4017 // | [SUBS CREATE] |
4020 // | RESTSubDelReq | |
4021 // |---------------->| |
4023 // | RESTSubDelResp | |
4024 // |<----------------| |
4026 // | |------------->|
4029 // | |------------->|
4032 // | |<-------------|
4035 //-----------------------------------------------------------------------------
4036 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
4037 CaseBegin("TestRESTSubDelReqRetryInSubmgr")
4039 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4040 Counter{cRestSubReqFromXapp, 1},
4041 Counter{cRestSubRespToXapp, 1},
4042 Counter{cSubReqToE2, 1},
4043 Counter{cSubRespFromE2, 1},
4044 Counter{cRestSubNotifToXapp, 1},
4045 Counter{cRestSubDelReqFromXapp, 1},
4046 Counter{cSubDelReqToE2, 1},
4047 Counter{cSubDelReqTimerExpiry, 1},
4048 Counter{cSubDelReReqToE2, 1},
4049 Counter{cSubDelRespFromE2, 1},
4050 Counter{cRestSubDelRespToXapp, 1},
4053 var params *teststube2ap.RESTSubsReqParams = nil
4054 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4057 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4059 // E2t: Receive 1st SubsDelReq
4060 e2termConn1.RecvSubsDelReq(t)
4062 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4063 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4064 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4066 //Wait that subs is cleaned
4067 waitSubsCleanup(t, e2SubsId, 10)
4069 mainCtrl.VerifyCounterValues(t)
4070 mainCtrl.VerifyAllClean(t)
4073 //-----------------------------------------------------------------------------
4074 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
4077 // +-------+ +---------+ +---------+
4078 // | xapp | | submgr | | e2term |
4079 // +-------+ +---------+ +---------+
4081 // | [SUBS CREATE] |
4084 // | RESTSubDelReq | |
4085 // |---------------->| |
4087 // | RESTSubDelResp | |
4088 // |<----------------| |
4090 // | |------------->|
4093 // | |------------->|
4097 //-----------------------------------------------------------------------------
4098 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
4099 CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr")
4101 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4102 Counter{cRestSubReqFromXapp, 1},
4103 Counter{cRestSubRespToXapp, 1},
4104 Counter{cSubReqToE2, 1},
4105 Counter{cSubRespFromE2, 1},
4106 Counter{cRestSubNotifToXapp, 1},
4107 Counter{cRestSubDelReqFromXapp, 1},
4108 Counter{cSubDelReqToE2, 1},
4109 Counter{cSubDelReqTimerExpiry, 1},
4110 Counter{cSubDelReReqToE2, 1},
4111 Counter{cSubDelRespFromE2, 1},
4112 Counter{cRestSubDelRespToXapp, 1},
4116 var params *teststube2ap.RESTSubsReqParams = nil
4117 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4120 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4122 // E2t: Receive 1st SubsDelReq
4123 e2termConn1.RecvSubsDelReq(t)
4125 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4126 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4127 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4129 //Wait that subs is cleaned
4130 waitSubsCleanup(t, e2SubsId, 10)
4132 mainCtrl.VerifyCounterValues(t)
4133 mainCtrl.VerifyAllClean(t)
4136 //-----------------------------------------------------------------------------
4137 // TestRESTSubDelReqSubDelFailRespInSubmgr
4140 // +-------+ +---------+ +---------+
4141 // | xapp | | submgr | | e2term |
4142 // +-------+ +---------+ +---------+
4144 // | [SUBS CREATE] |
4147 // | RESTSubDelReq | |
4148 // |---------------->| |
4150 // | RESTSubDelResp | |
4151 // |<----------------| |
4153 // | |------------->|
4156 // | |<-------------|
4159 //-----------------------------------------------------------------------------
4160 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
4161 CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr")
4163 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4164 Counter{cRestSubReqFromXapp, 1},
4165 Counter{cRestSubRespToXapp, 1},
4166 Counter{cSubReqToE2, 1},
4167 Counter{cSubRespFromE2, 1},
4168 Counter{cRestSubNotifToXapp, 1},
4169 Counter{cRestSubDelReqFromXapp, 1},
4170 Counter{cSubDelReqToE2, 1},
4171 Counter{cSubDelFailFromE2, 1},
4172 Counter{cRestSubDelRespToXapp, 1},
4176 var params *teststube2ap.RESTSubsReqParams = nil
4177 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4180 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4182 // E2t: Send receive SubsDelReq and send SubsDelFail
4183 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4184 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
4186 //Wait that subs is cleaned
4187 waitSubsCleanup(t, e2SubsId, 10)
4189 mainCtrl.VerifyCounterValues(t)
4190 mainCtrl.VerifyAllClean(t)
4193 //-----------------------------------------------------------------------------
4194 // TestRESTSubReqAndSubDelOkSameAction
4197 // +-------+ +-------+ +---------+ +---------+
4198 // | xapp2 | | xapp1 | | submgr | | e2term |
4199 // +-------+ +-------+ +---------+ +---------+
4201 // | | RESTSubReq1 | |
4202 // | |---------------->| |
4204 // | | RESTSubResp1 | |
4205 // | |<----------------| |
4208 // | | |------------->|
4210 // | | |<-------------|
4211 // | | RESTNotif1 | |
4212 // | |<----------------| |
4214 // | RESTSubReq2 | |
4215 // |------------------------------>| |
4217 // | RESTSubResp2 | |
4218 // |<------------------------------| |
4220 // | | RESTNotif2 | |
4221 // |<------------------------------| |
4223 // | | RESTSubDelReq1 | |
4224 // | |---------------->| |
4226 // | | RESTSubDelResp1 | |
4227 // | |<----------------| |
4229 // | RESTSubDelReq2 | |
4230 // |------------------------------>| |
4232 // | RESTSubDelResp2 | |
4233 // |<------------------------------| |
4235 // | | | SubDelReq2 |
4236 // | | |------------->|
4238 // | | | SubDelResp2 |
4239 // | | |<-------------|
4242 //-----------------------------------------------------------------------------
4243 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
4244 CaseBegin("TestRESTSubReqAndSubDelOkSameAction")
4246 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4247 Counter{cRestSubReqFromXapp, 2},
4248 Counter{cRestSubRespToXapp, 2},
4249 Counter{cSubReqToE2, 1},
4250 Counter{cSubRespFromE2, 1},
4251 Counter{cRestSubNotifToXapp, 2},
4252 Counter{cMergedSubscriptions, 1},
4253 Counter{cUnmergedSubscriptions, 1},
4254 Counter{cRestSubDelReqFromXapp, 2},
4255 Counter{cSubDelReqToE2, 1},
4256 Counter{cSubDelRespFromE2, 1},
4257 Counter{cRestSubDelRespToXapp, 2},
4261 var params *teststube2ap.RESTSubsReqParams = nil
4264 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4265 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4268 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4269 params.SetMeid("RAN_NAME_1")
4271 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4272 xappConn2.ExpectAnyNotification(t)
4273 waiter := rtmgrHttp.AllocNextSleep(10, true)
4274 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4275 waiter.WaitResult(t)
4276 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
4277 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
4278 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
4280 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
4283 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4286 deleteXapp2Subscription(t, &restSubId2)
4288 //Wait that subs is cleaned
4289 waitSubsCleanup(t, e2SubsId2, 10)
4290 mainCtrl.VerifyCounterValues(t)
4291 mainCtrl.VerifyAllClean(t)
4294 //-----------------------------------------------------------------------------
4295 // TestSubReqAndSubDelOkSameActionParallel
4298 // +-------+ +-------+ +---------+ +---------+
4299 // | xapp2 | | xapp1 | | submgr | | e2term |
4300 // +-------+ +-------+ +---------+ +---------+
4305 // | |------------->| |
4308 // | | |------------->|
4310 // |--------------------------->| |
4312 // | | |<-------------|
4314 // | |<-------------| |
4316 // | | |------------->|
4319 // | | |<-------------|
4321 // |<---------------------------| |
4323 // | | SubDelReq 1 | |
4324 // | |------------->| |
4326 // | | SubDelResp 1 | |
4327 // | |<-------------| |
4329 // | SubDelReq 2 | |
4330 // |--------------------------->| |
4332 // | | | SubDelReq 2 |
4333 // | | |------------->|
4335 // | | | SubDelReq 2 |
4336 // | | |------------->|
4338 // | SubDelResp 2 | |
4339 // |<---------------------------| |
4341 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
4342 CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel")
4344 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4345 Counter{cRestSubReqFromXapp, 2},
4346 Counter{cRestSubRespToXapp, 2},
4347 Counter{cSubReqToE2, 2},
4348 Counter{cSubRespFromE2, 2},
4349 Counter{cRestSubNotifToXapp, 2},
4350 Counter{cRestSubDelReqFromXapp, 2},
4351 Counter{cSubDelReqToE2, 2},
4352 Counter{cSubDelRespFromE2, 2},
4353 Counter{cRestSubDelRespToXapp, 2},
4356 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4357 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4358 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4360 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4361 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4363 xappConn1.ExpectRESTNotification(t, restSubId1)
4364 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4365 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4367 xappConn2.ExpectRESTNotification(t, restSubId2)
4368 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
4369 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
4370 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4373 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4374 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4375 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4376 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4379 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4380 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
4381 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
4383 waitSubsCleanup(t, e2SubsId2, 10)
4384 mainCtrl.VerifyCounterValues(t)
4385 mainCtrl.VerifyAllClean(t)
4388 //-----------------------------------------------------------------------------
4389 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
4392 // +-------+ +-------+ +---------+ +---------+
4393 // | xapp2 | | xapp1 | | submgr | | e2term |
4394 // +-------+ +-------+ +---------+ +---------+
4398 // | | RESTSubReq1 | |
4399 // | |---------------->| |
4401 // | | RESTSubResp1 | |
4402 // | |<----------------| |
4404 // | | |------------->|
4405 // | RESTSubReq2 | |
4406 // |------------------------------>| |
4408 // | RESTSubResp2 | |
4409 // |<------------------------------| |
4411 // | | |------------->|
4414 // | | | SubDelReq |
4415 // | | |------------->|
4417 // | | | SubDelResp |
4418 // | | |<-------------|
4419 // | | RESTNotif1 | |
4420 // | | unsuccess | |
4421 // | |<----------------| |
4423 // | | unsuccess | |
4424 // |<------------------------------| |
4426 // | | RESTSubDelReq1 | |
4427 // | |---------------->| |
4429 // | | RESTSubDelResp1 | |
4430 // | |<----------------| |
4432 // | RESTSubDelReq2 | |
4433 // |------------------------------>| |
4435 // | RESTSubDelResp2 | |
4436 // |<------------------------------| |
4438 //-----------------------------------------------------------------------------
4439 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
4440 CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
4442 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4443 Counter{cRestSubReqFromXapp, 2},
4444 Counter{cMergedSubscriptions, 1},
4445 Counter{cRestSubRespToXapp, 2},
4446 Counter{cSubReqToE2, 1},
4447 Counter{cSubReqTimerExpiry, 2},
4448 Counter{cSubReReqToE2, 1},
4449 Counter{cRestSubFailNotifToXapp, 2},
4450 Counter{cUnmergedSubscriptions, 1},
4451 Counter{cRestSubDelReqFromXapp, 2},
4452 Counter{cSubDelReqToE2, 1},
4453 Counter{cSubDelRespFromE2, 1},
4454 Counter{cRestSubDelRespToXapp, 2},
4456 const subReqCount int = 1
4459 params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4460 restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
4461 crereq1, _ := e2termConn1.RecvSubsReq(t)
4464 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4465 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4466 params2.SetMeid("RAN_NAME_1")
4467 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4468 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4470 //Req1 (retransmitted)
4471 e2termConn1.RecvSubsReq(t)
4473 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4475 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4476 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4478 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4479 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4480 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4481 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4484 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4487 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4489 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
4491 //Wait that subs is cleaned
4492 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4493 mainCtrl.VerifyCounterValues(t)
4494 mainCtrl.VerifyAllClean(t)
4497 //-----------------------------------------------------------------------------
4498 // TestRESTSubReqAndSubDelNokSameActionParallel
4501 // +-------+ +-------+ +---------+ +---------+
4502 // | xapp2 | | xapp1 | | submgr | | e2term |
4503 // +-------+ +-------+ +---------+ +---------+
4507 // | | RESTSubReq1 | |
4508 // | |---------------->| |
4510 // | | RESTSubResp1 | |
4511 // | |<----------------| |
4513 // | | |------------->|
4514 // | RESTSubReq2 | |
4515 // |------------------------------>| |
4517 // | RESTSubDelResp2 | |
4518 // |<------------------------------| |
4520 // | | |<-------------|
4522 // | | RESTNotif1 | |
4523 // | | unsuccess | |
4524 // | |<----------------| |
4526 // | | unsuccess | |
4527 // |<------------------------------| |
4529 // | | RESTSubDelReq1 | | There is no need for xApp to send delete for failed subscriptions but some xApp might do so.
4530 // | |---------------->| |
4532 // | | RESTSubDelResp1 | |
4533 // | |<----------------| |
4535 // | RESTSubDelReq2 | |
4536 // |------------------------------>| |
4538 // | RESTSubDelResp2 | |
4539 // |<------------------------------| |
4541 //-----------------------------------------------------------------------------
4542 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
4543 CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
4545 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4546 Counter{cRestSubReqFromXapp, 2},
4547 Counter{cMergedSubscriptions, 1},
4548 Counter{cRestSubRespToXapp, 2},
4549 Counter{cSubReqToE2, 1},
4550 Counter{cSubFailFromE2, 1},
4551 Counter{cRestSubFailNotifToXapp, 2},
4552 Counter{cUnmergedSubscriptions, 1},
4553 Counter{cRestSubDelReqFromXapp, 2},
4554 Counter{cRestSubDelRespToXapp, 2},
4557 const subReqCount int = 1
4560 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4561 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4562 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4565 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4566 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4567 params2.SetMeid("RAN_NAME_1")
4568 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4569 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4571 // E2t: send SubsFail (first)
4572 fparams1 := &teststube2ap.E2StubSubsFailParams{}
4573 fparams1.Set(crereq1)
4574 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
4576 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4577 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4578 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4579 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4580 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4583 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4586 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4588 //Wait that subs is cleaned
4589 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4590 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
4591 mainCtrl.VerifyCounterValues(t)
4592 mainCtrl.VerifyAllClean(t)
4595 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
4596 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4598 // Init counter check
4599 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4600 Counter{cRestSubReqFromXapp, 1},
4601 Counter{cRestSubRespToXapp, 1},
4602 Counter{cSubReqToE2, 1},
4603 Counter{cSubRespFromE2, 1},
4604 Counter{cRestSubNotifToXapp, 1},
4605 Counter{cRestSubDelReqFromXapp, 1},
4606 Counter{cSubDelReqToE2, 1},
4607 Counter{cSubDelRespFromE2, 1},
4608 Counter{cRestSubDelRespToXapp, 1},
4611 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4612 restSubId := xappConn1.SendRESTSubsReq(t, params)
4613 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
4615 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4616 xappConn1.ExpectRESTNotification(t, restSubId)
4617 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4618 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4619 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
4621 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4622 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4623 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4625 // Wait that subs is cleaned
4626 waitSubsCleanup(t, e2SubsId, 10)
4627 mainCtrl.VerifyCounterValues(t)
4628 mainCtrl.VerifyAllClean(t)
4631 //-----------------------------------------------------------------------------
4632 // TestRESTSubReqPolicyChangeAndSubDelOk
4635 // +-------+ +---------+ +---------+
4636 // | xapp | | submgr | | e2term |
4637 // +-------+ +---------+ +---------+
4640 // |---------------->| |
4642 // | RESTSubResp | |
4643 // |<----------------| |
4645 // | |------------->|
4648 // | |<-------------|
4651 // |<----------------| |
4654 // |---------------->| |
4656 // | RESTSubResp | |
4657 // |<----------------| |
4659 // | |------------->|
4662 // | |<-------------|
4665 // |<----------------| |
4667 // | RESTSubDelReq | |
4668 // |---------------->| |
4671 // | |------------->|
4674 // | |<-------------|
4676 // | RESTSubDelResp | |
4677 // |<----------------| |
4679 //-----------------------------------------------------------------------------
4680 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
4681 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4683 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4684 Counter{cRestSubReqFromXapp, 2},
4685 Counter{cRestSubRespToXapp, 2},
4686 Counter{cSubReqToE2, 2},
4687 Counter{cSubRespFromE2, 2},
4688 Counter{cRestSubNotifToXapp, 2},
4689 Counter{cRestSubDelReqFromXapp, 1},
4690 Counter{cSubDelReqToE2, 1},
4691 Counter{cSubDelRespFromE2, 1},
4692 Counter{cRestSubDelRespToXapp, 1},
4695 const subReqCount int = 1
4696 const e2Timeout int64 = 1
4697 const e2RetryCount int64 = 0
4698 const routingNeeded bool = true
4701 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4702 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4703 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4706 // GetRESTSubsReqPolicyParams sets some counters on tc side.
4708 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4709 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4710 params.SetSubscriptionID(&restSubId)
4711 params.SetTimeToWait("w200ms")
4712 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
4715 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4717 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4718 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4720 // Wait that subs is cleaned
4721 waitSubsCleanup(t, e2SubsId, 10)
4722 mainCtrl.VerifyCounterValues(t)
4723 mainCtrl.VerifyAllClean(t)
4726 //-----------------------------------------------------------------------------
4727 // TestRESTSubReqPolicyChangeNOk
4730 // +-------+ +---------+ +---------+
4731 // | xapp | | submgr | | e2term |
4732 // +-------+ +---------+ +---------+
4735 // |---------------->| |
4737 // | RESTSubResp | |
4738 // |<----------------| |
4740 // | |------------->|
4743 // | |<-------------|
4746 // |<----------------| |
4749 // |---------------->| |
4751 // | RESTSubUpdateFail(400 Bad request)
4753 // | RESTSubDelReq | |
4754 // |---------------->| |
4757 // | |------------->|
4760 // | |<-------------|
4762 // | RESTSubDelResp | |
4763 // |<----------------| |
4765 //-----------------------------------------------------------------------------
4766 func TestRESTSubReqPolicyChangeNOk(t *testing.T) {
4767 CaseBegin("TestRESTSubReqPolicyChangeNOk")
4769 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4770 Counter{cRestSubReqFromXapp, 2},
4771 Counter{cRestSubRespToXapp, 1},
4772 Counter{cSubReqToE2, 1},
4773 Counter{cSubRespFromE2, 1},
4774 Counter{cRestSubNotifToXapp, 1},
4775 Counter{cRestSubFailToXapp, 1},
4776 Counter{cRestSubDelReqFromXapp, 1},
4777 Counter{cSubDelReqToE2, 1},
4778 Counter{cSubDelRespFromE2, 1},
4779 Counter{cRestSubDelRespToXapp, 1},
4783 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4784 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4787 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4789 restSubIdUpd := strings.ToUpper(restSubId) // This makes RESTSubReq to fail
4790 params.SetSubscriptionID(&restSubIdUpd)
4791 params.SetTimeToWait("w200ms")
4793 restSubId2 := xappConn1.SendRESTSubsReq(t, params)
4794 assert.Equal(t, restSubId2, "")
4797 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4799 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4800 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4802 // Wait that subs is cleaned
4803 waitSubsCleanup(t, e2SubsId, 10)
4804 mainCtrl.VerifyCounterValues(t)
4805 mainCtrl.VerifyAllClean(t)
4808 //-----------------------------------------------------------------------------
4809 // TestRESTSubReqAndSubDelOkTwoE2termParallel
4812 // +-------+ +---------+ +---------+ +---------+
4813 // | xapp | | submgr | | e2term1 | | e2term2 |
4814 // +-------+ +---------+ +---------+ +---------+
4818 // | RESTSubReq1 | | |
4819 // |---------------->| | |
4821 // | RESTSubResp1 | | |
4822 // |<----------------| | |
4824 // | |------------->| |
4826 // | RESTSubReq2 | | |
4827 // |---------------->| | |
4829 // | RESTSubResp2 | | |
4830 // |<----------------| | |
4832 // | |---------------------------->|
4835 // | |<-------------| |
4836 // | RESTNotif1 | | |
4837 // |<----------------| | |
4839 // | |<----------------------------|
4840 // | RESTNotif2 | | |
4841 // |<----------------| | |
4843 // | [SUBS 1 DELETE] | |
4845 // | [SUBS 2 DELETE] | |
4848 //-----------------------------------------------------------------------------
4849 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
4850 CaseBegin("TestRESTSubReqAndSubDelOkTwoE2termParallel")
4852 // Init counter check
4853 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4854 Counter{cRestSubReqFromXapp, 2},
4855 Counter{cRestSubRespToXapp, 2},
4856 Counter{cSubReqToE2, 2},
4857 Counter{cSubRespFromE2, 2},
4858 Counter{cRestSubNotifToXapp, 2},
4859 Counter{cRestSubDelReqFromXapp, 2},
4860 Counter{cSubDelReqToE2, 2},
4861 Counter{cSubDelRespFromE2, 2},
4862 Counter{cRestSubDelRespToXapp, 2},
4865 const subReqCount int = 1
4868 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4869 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4870 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4873 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4874 params.SetMeid("RAN_NAME_11")
4875 // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
4876 // would not work as notification would not be received
4877 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4878 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
4881 xappConn1.ExpectRESTNotification(t, restSubId1)
4882 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4883 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4884 xapp.Logger.Debug("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
4887 xappConn2.ExpectRESTNotification(t, restSubId2)
4888 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
4889 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4890 xapp.Logger.Debug("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
4893 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4894 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4895 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4897 // Wait that subs is cleaned
4898 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4901 xappConn1.SendRESTSubsDelReq(t, &restSubId2)
4902 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
4903 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
4905 // Wait that subs is cleaned
4906 waitSubsCleanup(t, e2SubsId2, 10)
4908 mainCtrl.VerifyCounterValues(t)
4909 mainCtrl.VerifyAllClean(t)
4912 //-----------------------------------------------------------------------------
4913 // TestRESTSubReqAsn1EncodeFail
4915 // In this case submgr send RICSubscriptionDeleteRequest after encode failure which should not happen!
4917 // +-------+ +---------+ +---------+
4918 // | xapp | | submgr | | e2term |
4919 // +-------+ +---------+ +---------+
4922 // |---------------->| |
4924 // | RESTSubResp | |
4925 // |<----------------| |
4926 // | RESTSubDelReq | |
4927 // |---------------->| |
4928 // | RESTSubDelResp | |
4930 // |<----------------| |
4933 //-----------------------------------------------------------------------------
4934 func TestRESTSubReqAsn1EncodeFail(t *testing.T) {
4935 CaseBegin("TestRESTSubReqAsn1EncodeFail")
4937 xapp.Logger.Debug("Xapp-frame, v0.8.1 sufficient REST API validation")
4941 //-----------------------------------------------------------------------------
4942 // TestRESTSubReqInsertAndSubDelOk
4945 // +-------+ +---------+ +---------+
4946 // | xapp | | submgr | | e2term |
4947 // +-------+ +---------+ +---------+
4950 // |---------------->| |
4952 // | RESTSubResp | |
4953 // |<----------------| |
4956 // | |------------->|
4959 // | |<-------------|
4961 // |<----------------| |
4964 // | RESTSubDelReq | |
4965 // |---------------->| |
4968 // | |------------->|
4971 // | |<-------------|
4973 // | RESTSubDelResp| |
4974 // |<----------------| |
4976 //-----------------------------------------------------------------------------
4977 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
4978 CaseBegin("TestRESTInsertSubReqAndSubDelOk")
4980 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4981 Counter{cRestSubReqFromXapp, 1},
4982 Counter{cRestSubRespToXapp, 1},
4983 Counter{cSubReqToE2, 1},
4984 Counter{cSubRespFromE2, 1},
4985 Counter{cRestSubNotifToXapp, 1},
4986 Counter{cRestSubDelReqFromXapp, 1},
4987 Counter{cSubDelReqToE2, 1},
4988 Counter{cSubDelRespFromE2, 1},
4989 Counter{cRestSubDelRespToXapp, 1},
4992 const subReqCount int = 1
4994 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4995 params.SetSubActionTypes("insert")
4998 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5001 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5003 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5004 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5006 // Wait that subs is cleaned
5007 waitSubsCleanup(t, e2SubsId, 10)
5008 mainCtrl.VerifyCounterValues(t)
5009 mainCtrl.VerifyAllClean(t)
5012 //-----------------------------------------------------------------------------
5013 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
5016 // +-------+ +---------+ +---------+
5017 // | xapp | | submgr | | e2term |
5018 // +-------+ +---------+ +---------+
5021 // |------------->| |
5023 // | RESTSubResp | |
5024 // |<-------------| |
5026 // | |------------->|
5031 // | Submgr restart |
5035 // | |------------->|
5038 // | |<-------------|
5042 // |<-------------| |
5044 // | RESTSubDelReq| |
5045 // |------------->| |
5047 // |RESTSubDelResp| |
5048 // |<-------------| |
5050 //-----------------------------------------------------------------------------
5051 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
5052 CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle")
5054 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5055 Counter{cRestSubReqFromXapp, 1},
5056 Counter{cRestSubRespToXapp, 1},
5057 Counter{cSubReqToE2, 1},
5058 Counter{cSubDelReqFromXapp, 1},
5059 Counter{cSubDelReqToE2, 1},
5060 Counter{cSubDelRespFromE2, 1},
5061 Counter{cRestSubDelReqFromXapp, 1},
5062 Counter{cRestSubDelRespToXapp, 1},
5065 const subReqCount int = 1
5067 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5070 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
5071 restSubId := xappConn1.SendRESTSubsReq(t, params)
5072 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5074 e2termConn1.RecvSubsReq(t)
5076 mainCtrl.SetResetTestFlag(t, false)
5078 mainCtrl.SimulateRestart(t)
5079 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5081 // Deleletion of uncompleted subscription
5082 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5083 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5086 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5088 xappConn1.TestMsgChanEmpty(t)
5089 e2termConn1.TestMsgChanEmpty(t)
5090 mainCtrl.wait_registry_empty(t, 10)
5092 mainCtrl.VerifyCounterValues(t)
5093 mainCtrl.VerifyAllClean(t)
5096 //-----------------------------------------------------------------------------
5097 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
5100 // +-------+ +---------+ +---------+
5101 // | xapp | | submgr | | e2term |
5102 // +-------+ +---------+ +---------+
5105 // |---------------->| |
5107 // | RESTSubResp | |
5108 // |<----------------| |
5110 // | |------------->|
5113 // | |<-------------|
5116 // |<----------------| |
5119 // | Submgr restart |
5121 // | RESTSubDelReq | |
5122 // |---------------->| |
5125 // | |------------->|
5128 // | |<-------------|
5130 // | RESTSubDelResp | |
5131 // |<----------------| |
5133 //-----------------------------------------------------------------------------
5135 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
5136 CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle")
5138 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5139 Counter{cRestSubReqFromXapp, 1},
5140 Counter{cRestSubRespToXapp, 1},
5141 Counter{cSubReqToE2, 1},
5142 Counter{cSubRespFromE2, 1},
5143 Counter{cRestSubNotifToXapp, 1},
5144 Counter{cRestSubDelReqFromXapp, 1},
5145 Counter{cSubDelReqToE2, 1},
5146 Counter{cSubDelRespFromE2, 1},
5147 Counter{cRestSubDelRespToXapp, 1},
5150 // Create subscription
5151 var params *teststube2ap.RESTSubsReqParams = nil
5152 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5153 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5155 // Check subscription
5156 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5158 mainCtrl.SimulateRestart(t)
5159 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5161 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5162 // That needs to be completed before successful subscription query is possible
5163 <-time.After(time.Second * 1)
5165 // Check subscription
5166 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5168 // Delete subscription
5169 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
5171 //Wait that subs is cleaned
5172 waitSubsCleanup(t, e2SubsId, 10)
5174 mainCtrl.VerifyCounterValues(t)
5175 mainCtrl.VerifyAllClean(t)
5178 //-----------------------------------------------------------------------------
5179 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
5182 // +-------+ +-------+ +---------+ +---------+
5183 // | xapp2 | | xapp1 | | submgr | | e2term |
5184 // +-------+ +-------+ +---------+ +---------+
5186 // | | RESTSubReq1 | |
5187 // | |---------------->| |
5189 // | | RESTSubResp1 | |
5190 // | |<----------------| |
5193 // | | |------------->|
5195 // | | |<-------------|
5196 // | | RESTNotif1 | |
5197 // | |<----------------| |
5199 // | RESTSubReq2 | |
5200 // |------------------------------>| |
5202 // | RESTSubResp2 | |
5203 // |<------------------------------| |
5205 // | | RESTNotif2 | |
5206 // |<------------------------------| |
5208 // | | Submgr restart |
5210 // | | RESTSubDelReq1 | |
5211 // | |---------------->| |
5213 // | | RESTSubDelResp1 | |
5214 // | |<----------------| |
5216 // | | Submgr restart |
5218 // | RESTSubDelReq2 | |
5219 // |------------------------------>| |
5221 // | RESTSubDelResp2 | |
5222 // |<------------------------------| |
5224 // | | | SubDelReq2 |
5225 // | | |------------->|
5227 // | | | SubDelResp2 |
5228 // | | |<-------------|
5231 //-----------------------------------------------------------------------------
5232 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
5233 CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
5235 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5236 Counter{cRestSubReqFromXapp, 2},
5237 Counter{cRestSubRespToXapp, 2},
5238 Counter{cSubReqToE2, 1},
5239 Counter{cSubRespFromE2, 1},
5240 Counter{cRestSubNotifToXapp, 2},
5241 Counter{cMergedSubscriptions, 1},
5242 Counter{cUnmergedSubscriptions, 1},
5243 Counter{cRestSubDelReqFromXapp, 2},
5244 Counter{cSubDelReqToE2, 1},
5245 Counter{cSubDelRespFromE2, 1},
5246 Counter{cRestSubDelRespToXapp, 2},
5249 // Create subscription 1
5250 var params *teststube2ap.RESTSubsReqParams = nil
5251 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5252 xapp.Logger.Debug("Send REST subscriber request for subscriber 1 : %v", restSubId1)
5254 // Create subscription 2 with same action
5255 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5256 params.SetMeid("RAN_NAME_1")
5257 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
5258 xappConn2.ExpectAnyNotification(t)
5259 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5260 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5261 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
5262 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
5264 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
5266 mainCtrl.SimulateRestart(t)
5267 xapp.Logger.Debug("mainCtrl.SimulateRestart done 1")
5269 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5270 // That needs to be completed before successful subscription delete is possible
5271 <-time.After(time.Second * 1)
5273 // Delete subscription 1, and wait until it has removed the first endpoint
5274 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5275 mainCtrl.WaitRESTSubscriptionDelete(restSubId1)
5276 // Above wait does not work correctly anymore as this delay makes this test case work
5278 mainCtrl.SimulateRestart(t)
5279 xapp.Logger.Debug("mainCtrl.SimulateRestart done 2")
5281 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5282 // That needs to be completed before successful subscription query is possible
5283 <-time.After(time.Second * 1)
5285 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
5287 // Delete subscription 2
5288 deleteXapp2Subscription(t, &restSubId2)
5290 //Wait that subs is cleaned
5291 waitSubsCleanup(t, e2SubsId2, 10)
5293 mainCtrl.VerifyCounterValues(t)
5294 mainCtrl.VerifyAllClean(t)
5297 //-----------------------------------------------------------------------------
5298 // TestRESTReportSubReqAndSubDelOk
5301 // +-------+ +---------+ +---------+
5302 // | xapp | | submgr | | e2term |
5303 // +-------+ +---------+ +---------+
5306 // |---------------->| |
5308 // | RESTSubResp | |
5309 // |<----------------| |
5312 // | |------------->|
5315 // | |<-------------|
5317 // |<----------------| |
5319 // | |------------->|
5322 // | |<-------------|
5324 // |<----------------| |
5328 // | RESTSubDelReq | |
5329 // |---------------->| |
5331 // | RESTSubDelResp| |
5332 // |<----------------| |
5334 // | |------------->|
5337 // | |<-------------|
5340 //-----------------------------------------------------------------------------
5342 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
5343 CaseBegin("TestRESTReportSubReqAndSubDelOk")
5344 const subReqCount int = 1
5346 RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
5349 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5350 xapp.Logger.Debug("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
5352 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5353 Counter{cRestSubReqFromXapp, 1},
5354 Counter{cRestSubRespToXapp, 1},
5355 Counter{cSubReqToE2, uint64(subReqCount)},
5356 Counter{cSubRespFromE2, uint64(subReqCount)},
5357 Counter{cRestSubNotifToXapp, 1},
5358 Counter{cRestSubDelReqFromXapp, 1},
5359 Counter{cRestSubDelRespToXapp, 1},
5360 Counter{cSubDelReqToE2, uint64(subReqCount)},
5361 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5365 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5366 restSubId := xappConn1.SendRESTSubsReq(t, params)
5368 var e2SubsId []uint32
5369 for i := 0; i < subReqCount; i++ {
5370 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5371 xappConn1.ExpectRESTNotification(t, restSubId)
5373 e2termConn1.SendSubsResp(t, crereq, cremsg)
5374 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5375 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5376 e2SubsId = append(e2SubsId, instanceId)
5377 resp, _ := xapp.Subscription.QuerySubscriptions()
5378 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
5379 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
5380 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
5385 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5387 for i := 0; i < subReqCount; i++ {
5388 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5389 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5392 // Wait that subs is cleaned
5393 for i := 0; i < subReqCount; i++ {
5394 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5397 xappConn1.TestMsgChanEmpty(t)
5398 e2termConn1.TestMsgChanEmpty(t)
5399 mainCtrl.wait_registry_empty(t, 10)
5400 mainCtrl.VerifyAllClean(t)
5401 mainCtrl.VerifyCounterValues(t)
5405 func TestRESTPolicySubReqAndSubDelOk(t *testing.T) { //Was in comments already. Next case is not run!
5406 CaseBegin("TestRESTPolicySubReqAndSubDelOk")
5410 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5414 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5417 func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5418 xapp.Logger.Debug("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
5420 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5421 Counter{cRestSubReqFromXapp, 1},
5422 Counter{cRestSubRespToXapp, 1},
5423 Counter{cSubReqToE2, uint64(subReqCount)},
5424 Counter{cSubRespFromE2, uint64(subReqCount)},
5425 Counter{cRestSubNotifToXapp, 1},
5426 Counter{cRestSubDelReqFromXapp, 1},
5427 Counter{cRestSubDelRespToXapp, 1},
5428 Counter{cSubDelReqToE2, uint64(subReqCount)},
5429 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5433 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5434 restSubId := xappConn1.SendRESTSubsReq(t, params)
5436 var e2SubsId []uint32
5437 for i := 0; i < subReqCount; i++ {
5438 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5439 xappConn1.ExpectRESTNotification(t, restSubId)
5440 e2termConn1.SendSubsResp(t, crereq, cremsg)
5441 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5442 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5443 e2SubsId = append(e2SubsId, instanceId)
5447 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5449 for i := 0; i < subReqCount; i++ {
5450 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5451 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5454 // Wait that subs is cleaned
5455 for i := 0; i < subReqCount; i++ {
5456 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5458 xappConn1.TestMsgChanEmpty(t)
5459 e2termConn1.TestMsgChanEmpty(t)
5460 mainCtrl.wait_registry_empty(t, 10)
5461 mainCtrl.VerifyAllClean(t)
5462 mainCtrl.VerifyCounterValues(t)
5465 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
5467 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5468 Counter{cRestSubReqFromXapp, 1},
5469 Counter{cRestSubRespToXapp, 1},
5470 Counter{cSubReqToE2, 2},
5471 Counter{cSubRespFromE2, 2},
5472 Counter{cRestSubNotifToXapp, 2},
5473 Counter{cRestSubDelReqFromXapp, 1},
5474 Counter{cSubDelReqToE2, 2},
5475 Counter{cSubDelRespFromE2, 2},
5476 Counter{cRestSubDelRespToXapp, 1},
5479 const subReqCount int = 2
5482 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5483 restSubId := xappConn1.SendRESTSubsReq(t, params)
5484 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5486 assert.Equal(t, len(e2SubsIds), 2)
5489 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5490 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5492 xappConn1.TestMsgChanEmpty(t)
5493 e2termConn1.TestMsgChanEmpty(t)
5494 mainCtrl.wait_registry_empty(t, 10)
5496 mainCtrl.VerifyCounterValues(t)
5497 mainCtrl.VerifyAllClean(t)
5499 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
5501 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5502 Counter{cRestSubReqFromXapp, 1},
5503 Counter{cRestSubRespToXapp, 1},
5504 Counter{cSubReqToE2, 19},
5505 Counter{cSubRespFromE2, 19},
5506 Counter{cRestSubNotifToXapp, 19},
5507 Counter{cRestSubDelReqFromXapp, 1},
5508 Counter{cSubDelReqToE2, 19},
5509 Counter{cSubDelRespFromE2, 19},
5510 Counter{cRestSubDelRespToXapp, 1},
5513 const subReqCount int = 19
5515 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5516 restSubId := xappConn1.SendRESTSubsReq(t, params)
5517 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5519 assert.Equal(t, len(e2SubsIds), 19)
5521 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5522 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5524 xappConn1.TestMsgChanEmpty(t)
5525 e2termConn1.TestMsgChanEmpty(t)
5526 mainCtrl.wait_registry_empty(t, 10)
5528 mainCtrl.VerifyCounterValues(t)
5529 mainCtrl.VerifyAllClean(t)
5532 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
5536 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5537 Counter{cRestSubReqFromXapp, 1},
5538 Counter{cRestSubRespToXapp, 1},
5539 Counter{cSubReqToE2, uint64(subReqCount)},
5540 Counter{cSubRespFromE2, uint64(subReqCount)},
5541 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5542 Counter{cRestSubDelReqFromXapp, 1},
5543 Counter{cSubDelReqToE2, uint64(subReqCount)},
5544 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5545 Counter{cRestSubDelRespToXapp, 1},
5549 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5550 restSubId := xappConn1.SendRESTSubsReq(t, params)
5551 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5553 assert.Equal(t, len(e2SubsIds), subReqCount)
5556 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5557 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5559 xappConn1.TestMsgChanEmpty(t)
5560 e2termConn1.TestMsgChanEmpty(t)
5561 mainCtrl.wait_registry_empty(t, 10)
5563 mainCtrl.VerifyCounterValues(t)
5564 mainCtrl.VerifyAllClean(t)
5567 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
5571 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5572 Counter{cRestSubReqFromXapp, 1},
5573 Counter{cRestSubRespToXapp, 1},
5574 Counter{cSubReqToE2, uint64(subReqCount)},
5575 Counter{cSubRespFromE2, uint64(subReqCount)},
5576 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5577 Counter{cRestSubDelReqFromXapp, 1},
5578 Counter{cSubDelReqToE2, uint64(subReqCount)},
5579 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5580 Counter{cRestSubDelRespToXapp, 1},
5584 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5585 restSubId := xappConn1.SendRESTSubsReq(t, params)
5586 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5588 assert.Equal(t, len(e2SubsIds), subReqCount)
5591 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5592 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5594 xappConn1.TestMsgChanEmpty(t)
5595 e2termConn1.TestMsgChanEmpty(t)
5596 mainCtrl.wait_registry_empty(t, 10)
5598 mainCtrl.VerifyCounterValues(t)
5599 mainCtrl.VerifyAllClean(t)
5602 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
5606 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5607 Counter{cRestSubReqFromXapp, 1},
5608 Counter{cRestSubRespToXapp, 1},
5609 Counter{cSubReqToE2, uint64(subReqCount)},
5610 Counter{cSubRespFromE2, uint64(subReqCount)},
5611 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5612 Counter{cRestSubDelReqFromXapp, 1},
5613 Counter{cSubDelReqToE2, uint64(subReqCount)},
5614 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5615 Counter{cRestSubDelRespToXapp, 1},
5619 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5620 restSubId := xappConn1.SendRESTSubsReq(t, params)
5621 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5623 assert.Equal(t, len(e2SubsIds), subReqCount)
5626 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5627 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5629 xappConn1.TestMsgChanEmpty(t)
5630 e2termConn1.TestMsgChanEmpty(t)
5631 mainCtrl.wait_registry_empty(t, 10)
5633 mainCtrl.VerifyCounterValues(t)
5634 mainCtrl.VerifyAllClean(t)
5637 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
5638 CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
5640 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5641 Counter{cRestSubReqFromXapp, 2},
5642 Counter{cRestSubRespToXapp, 2},
5643 Counter{cSubReqToE2, 2},
5644 Counter{cSubRespFromE2, 2},
5645 Counter{cRestSubNotifToXapp, 2},
5646 Counter{cRestSubDelReqFromXapp, 2},
5647 Counter{cSubDelReqToE2, 2},
5648 Counter{cSubDelRespFromE2, 2},
5649 Counter{cRestSubDelRespToXapp, 2},
5653 var params *teststube2ap.RESTSubsReqParams = nil
5656 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5657 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5659 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5662 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5663 params.SetMeid("RAN_NAME_1")
5664 eventTriggerDefinition := []int64{1234, 1}
5665 params.SetSubEventTriggerDefinition(eventTriggerDefinition)
5667 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5668 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5669 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5670 xappConn2.ExpectRESTNotification(t, restSubId2)
5671 e2termConn1.SendSubsResp(t, crereq, cremsg)
5672 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5674 deleteXapp1Subscription(t, &restSubId1)
5675 deleteXapp2Subscription(t, &restSubId2)
5677 waitSubsCleanup(t, e2SubsId1, 10)
5678 waitSubsCleanup(t, e2SubsId2, 10)
5680 mainCtrl.VerifyCounterValues(t)
5681 mainCtrl.VerifyAllClean(t)
5684 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
5685 CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
5687 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5688 Counter{cRestSubReqFromXapp, 2},
5689 Counter{cRestSubRespToXapp, 2},
5690 Counter{cSubReqToE2, 2},
5691 Counter{cSubRespFromE2, 2},
5692 Counter{cRestSubNotifToXapp, 2},
5693 Counter{cRestSubDelReqFromXapp, 2},
5694 Counter{cSubDelReqToE2, 2},
5695 Counter{cSubDelRespFromE2, 2},
5696 Counter{cRestSubDelRespToXapp, 2},
5700 var params *teststube2ap.RESTSubsReqParams = nil
5703 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5704 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5706 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5709 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5710 params.SetMeid("RAN_NAME_1")
5712 actionId := int64(1)
5713 actionType := "report"
5714 actionDefinition := []int64{5678, 1}
5715 subsequestActionType := "continue"
5716 timeToWait := "w10ms"
5717 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
5719 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5720 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5721 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5722 xappConn2.ExpectRESTNotification(t, restSubId2)
5723 e2termConn1.SendSubsResp(t, crereq, cremsg)
5724 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5726 deleteXapp1Subscription(t, &restSubId1)
5727 deleteXapp2Subscription(t, &restSubId2)
5729 waitSubsCleanup(t, e2SubsId1, 10)
5730 waitSubsCleanup(t, e2SubsId2, 10)
5732 mainCtrl.VerifyCounterValues(t)
5733 mainCtrl.VerifyAllClean(t)
5736 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
5737 CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
5739 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5740 Counter{cRestSubReqFromXapp, 2},
5741 Counter{cRestSubRespToXapp, 2},
5742 Counter{cSubReqToE2, 2},
5743 Counter{cSubRespFromE2, 2},
5744 Counter{cRestSubNotifToXapp, 2},
5745 Counter{cRestSubDelReqFromXapp, 2},
5746 Counter{cSubDelReqToE2, 2},
5747 Counter{cSubDelRespFromE2, 2},
5748 Counter{cRestSubDelRespToXapp, 2},
5752 var params *teststube2ap.RESTSubsReqParams = nil
5755 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5756 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5758 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5761 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5762 params.SetMeid("RAN_NAME_1")
5763 params.SetSubActionIDs(int64(2))
5765 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5766 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5767 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5768 xappConn2.ExpectRESTNotification(t, restSubId2)
5769 e2termConn1.SendSubsResp(t, crereq, cremsg)
5770 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5772 deleteXapp1Subscription(t, &restSubId1)
5773 deleteXapp2Subscription(t, &restSubId2)
5775 waitSubsCleanup(t, e2SubsId1, 10)
5776 waitSubsCleanup(t, e2SubsId2, 10)
5778 mainCtrl.VerifyCounterValues(t)
5779 mainCtrl.VerifyAllClean(t)
5782 func TestRESTSubReqDiffActionType(t *testing.T) {
5783 CaseBegin("TestRESTSubReqDiffActionType")
5785 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5786 Counter{cRestSubReqFromXapp, 2},
5787 Counter{cRestSubRespToXapp, 2},
5788 Counter{cSubReqToE2, 2},
5789 Counter{cSubRespFromE2, 2},
5790 Counter{cRestSubNotifToXapp, 2},
5791 Counter{cRestSubDelReqFromXapp, 2},
5792 Counter{cSubDelReqToE2, 2},
5793 Counter{cSubDelRespFromE2, 2},
5794 Counter{cRestSubDelRespToXapp, 2},
5797 const e2Timeout int64 = 2
5798 const e2RetryCount int64 = 2
5799 const routingNeeded bool = true
5802 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5803 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5806 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5807 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5809 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5812 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5813 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5814 params.SetMeid("RAN_NAME_1")
5816 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5817 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5818 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5819 xappConn2.ExpectRESTNotification(t, restSubId2)
5820 e2termConn1.SendSubsResp(t, crereq, cremsg)
5821 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5823 deleteXapp1Subscription(t, &restSubId1)
5824 deleteXapp2Subscription(t, &restSubId2)
5826 waitSubsCleanup(t, e2SubsId1, 10)
5827 waitSubsCleanup(t, e2SubsId2, 10)
5829 mainCtrl.VerifyCounterValues(t)
5830 mainCtrl.VerifyAllClean(t)
5833 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
5834 CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
5836 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5837 Counter{cRestSubReqFromXapp, 2},
5838 Counter{cRestSubRespToXapp, 2},
5839 Counter{cSubReqToE2, 2},
5840 Counter{cSubRespFromE2, 2},
5841 Counter{cRestSubNotifToXapp, 2},
5842 Counter{cRestSubDelReqFromXapp, 2},
5843 Counter{cSubDelReqToE2, 2},
5844 Counter{cSubDelRespFromE2, 2},
5845 Counter{cRestSubDelRespToXapp, 2},
5848 const e2Timeout int64 = 2
5849 const e2RetryCount int64 = 2
5850 const routingNeeded bool = true
5853 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5854 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5857 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5858 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5860 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5863 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
5864 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5865 params.SetMeid("RAN_NAME_1")
5867 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5868 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5869 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5870 xappConn2.ExpectRESTNotification(t, restSubId2)
5871 e2termConn1.SendSubsResp(t, crereq, cremsg)
5872 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5874 deleteXapp1Subscription(t, &restSubId1)
5875 deleteXapp2Subscription(t, &restSubId2)
5877 waitSubsCleanup(t, e2SubsId1, 10)
5878 waitSubsCleanup(t, e2SubsId2, 10)
5880 mainCtrl.VerifyCounterValues(t)
5881 mainCtrl.VerifyAllClean(t)
5884 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
5885 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
5887 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5888 Counter{cRestSubReqFromXapp, 2},
5889 Counter{cRestSubRespToXapp, 2},
5890 Counter{cSubReqToE2, 2},
5891 Counter{cSubRespFromE2, 2},
5892 Counter{cRestSubNotifToXapp, 2},
5893 Counter{cRestSubDelReqFromXapp, 2},
5894 Counter{cSubDelReqToE2, 2},
5895 Counter{cSubDelRespFromE2, 2},
5896 Counter{cRestSubDelRespToXapp, 2},
5900 var params *teststube2ap.RESTSubsReqParams = nil
5903 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5904 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5906 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5909 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5910 params.SetMeid("RAN_NAME_1")
5911 actionDefinition := []int64{5678, 1}
5912 params.SetSubActionDefinition(actionDefinition)
5914 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5915 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5916 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5917 xappConn2.ExpectRESTNotification(t, restSubId2)
5918 e2termConn1.SendSubsResp(t, crereq, cremsg)
5919 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5921 deleteXapp1Subscription(t, &restSubId1)
5922 deleteXapp2Subscription(t, &restSubId2)
5924 waitSubsCleanup(t, e2SubsId1, 10)
5925 waitSubsCleanup(t, e2SubsId2, 10)
5927 mainCtrl.VerifyCounterValues(t)
5928 mainCtrl.VerifyAllClean(t)
5931 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
5932 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
5934 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5935 Counter{cRestSubReqFromXapp, 2},
5936 Counter{cRestSubRespToXapp, 2},
5937 Counter{cSubReqToE2, 2},
5938 Counter{cSubRespFromE2, 2},
5939 Counter{cRestSubNotifToXapp, 2},
5940 Counter{cRestSubDelReqFromXapp, 2},
5941 Counter{cSubDelReqToE2, 2},
5942 Counter{cSubDelRespFromE2, 2},
5943 Counter{cRestSubDelRespToXapp, 2},
5947 var params *teststube2ap.RESTSubsReqParams = nil
5950 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5951 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5953 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5956 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5957 params.SetMeid("RAN_NAME_1")
5958 actionDefinition := []int64{56782}
5959 params.SetSubActionDefinition(actionDefinition)
5961 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5962 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5963 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5964 xappConn2.ExpectRESTNotification(t, restSubId2)
5965 e2termConn1.SendSubsResp(t, crereq, cremsg)
5966 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5968 deleteXapp1Subscription(t, &restSubId1)
5969 deleteXapp2Subscription(t, &restSubId2)
5971 waitSubsCleanup(t, e2SubsId1, 10)
5972 waitSubsCleanup(t, e2SubsId2, 10)
5974 mainCtrl.VerifyCounterValues(t)
5975 mainCtrl.VerifyAllClean(t)
5978 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
5979 CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
5981 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5982 Counter{cRestSubReqFromXapp, 2},
5983 Counter{cRestSubRespToXapp, 2},
5984 Counter{cSubReqToE2, 2},
5985 Counter{cSubRespFromE2, 2},
5986 Counter{cRestSubNotifToXapp, 2},
5987 Counter{cRestSubDelReqFromXapp, 2},
5988 Counter{cSubDelReqToE2, 2},
5989 Counter{cSubDelRespFromE2, 2},
5990 Counter{cRestSubDelRespToXapp, 2},
5994 var params *teststube2ap.RESTSubsReqParams = nil
5997 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5998 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
6000 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
6003 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
6004 params.SetMeid("RAN_NAME_1")
6005 params.SetTimeToWait("w200ms")
6006 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
6007 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
6008 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6009 xappConn2.ExpectRESTNotification(t, restSubId2)
6010 e2termConn1.SendSubsResp(t, crereq, cremsg)
6011 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
6013 deleteXapp1Subscription(t, &restSubId1)
6014 deleteXapp2Subscription(t, &restSubId2)
6016 waitSubsCleanup(t, e2SubsId1, 10)
6017 waitSubsCleanup(t, e2SubsId2, 10)
6019 mainCtrl.VerifyCounterValues(t)
6020 mainCtrl.VerifyAllClean(t)
6023 //-----------------------------------------------------------------------------
6024 // TestRESTUnpackSubscriptionResponseDecodeFail
6027 // +-------+ +---------+ +---------+
6028 // | xapp | | submgr | | e2term |
6029 // +-------+ +---------+ +---------+
6032 // |---------------->| |
6034 // | RESTSubResp | |
6035 // |<----------------| |
6038 // | |------------->|
6040 // | | SubResp | ASN.1 decode fails
6041 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
6044 // | |------------->|
6046 // | | SubFail | Duplicated action
6047 // | |<-------------|
6048 // | RESTNotif (fail)| |
6049 // |<----------------| |
6051 // | [SUBS DELETE] |
6054 //-----------------------------------------------------------------------------
6056 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
6057 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
6059 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6060 Counter{cRestSubReqFromXapp, 1},
6061 Counter{cRestSubRespToXapp, 1},
6062 Counter{cSubReqToE2, 1},
6063 Counter{cSubReqTimerExpiry, 1},
6064 Counter{cSubReReqToE2, 1},
6065 Counter{cSubRespFromE2, 1},
6066 Counter{cSubFailFromE2, 1},
6067 Counter{cRestSubFailNotifToXapp, 1},
6068 Counter{cRestSubDelReqFromXapp, 1},
6069 Counter{cRestSubDelRespToXapp, 1},
6072 const subReqCount int = 1
6075 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6076 restSubId := xappConn1.SendRESTSubsReq(t, params)
6078 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6079 // Decode of this response fails which will result resending original request
6080 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
6082 _, cremsg = e2termConn1.RecvSubsReq(t)
6084 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6086 // Subscription already created in E2 Node.
6087 fparams := &teststube2ap.E2StubSubsFailParams{}
6089 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6090 e2termConn1.SendSubsFail(t, fparams, cremsg)
6092 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6093 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6095 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6097 // Wait that subs is cleaned
6098 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6100 xappConn1.TestMsgChanEmpty(t)
6101 e2termConn1.TestMsgChanEmpty(t)
6102 mainCtrl.wait_registry_empty(t, 10)
6103 mainCtrl.VerifyAllClean(t)
6104 mainCtrl.VerifyCounterValues(t)
6107 //-----------------------------------------------------------------------------
6108 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
6111 // +-------+ +---------+ +---------+
6112 // | xapp | | submgr | | e2term |
6113 // +-------+ +---------+ +---------+
6116 // |---------------->| |
6118 // | RESTSubResp | |
6119 // |<----------------| |
6122 // | |------------->|
6124 // | | SubResp | Unknown instanceId
6125 // | |<-------------| No valid subscription found with subIds [0]
6128 // | |------------->|
6130 // | | SubFail | Duplicated action
6131 // | |<-------------| No valid subscription found with subIds [0]
6132 // | RESTNotif (fail)| |
6133 // |<----------------| |
6135 // | |------------->|
6138 // | |<-------------|
6140 // | [SUBS DELETE] |
6143 //-----------------------------------------------------------------------------
6145 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
6146 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
6148 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6149 Counter{cRestSubReqFromXapp, 1},
6150 Counter{cRestSubRespToXapp, 1},
6151 Counter{cSubReqToE2, 1},
6152 Counter{cSubReqTimerExpiry, 2},
6153 Counter{cSubReReqToE2, 1},
6154 Counter{cSubRespFromE2, 1},
6155 Counter{cSubFailFromE2, 1},
6156 Counter{cRestSubFailNotifToXapp, 1},
6157 Counter{cRestSubDelReqFromXapp, 1},
6158 Counter{cRestSubDelRespToXapp, 1},
6159 Counter{cSubDelReqToE2, 1},
6160 Counter{cSubDelRespFromE2, 1},
6163 const subReqCount int = 1
6166 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6167 restSubId := xappConn1.SendRESTSubsReq(t, params)
6169 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6171 // Unknown instanceId 0 in this response which will result resending original request
6172 orgInstanceId := crereq.RequestId.InstanceId
6173 crereq.RequestId.InstanceId = 0
6174 e2termConn1.SendSubsResp(t, crereq, cremsg)
6176 _, cremsg = e2termConn1.RecvSubsReq(t)
6178 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6180 // Subscription already created in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
6181 fparams := &teststube2ap.E2StubSubsFailParams{}
6183 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6184 e2termConn1.SendSubsFail(t, fparams, cremsg)
6186 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6187 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6189 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6190 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6192 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6194 // Wait that subs is cleaned
6195 mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
6197 xappConn1.TestMsgChanEmpty(t)
6198 e2termConn1.TestMsgChanEmpty(t)
6199 mainCtrl.wait_registry_empty(t, 10)
6200 mainCtrl.VerifyAllClean(t)
6201 mainCtrl.VerifyCounterValues(t)
6204 //-----------------------------------------------------------------------------
6205 // TestRESTUnpackSubscriptionResponseNoTransaction
6208 // +-------+ +---------+ +---------+
6209 // | xapp | | submgr | | e2term |
6210 // +-------+ +---------+ +---------+
6213 // |---------------->| |
6215 // | RESTSubResp | |
6216 // |<----------------| |
6219 // | |------------->|
6221 // | | SubResp | No transaction for the response
6222 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
6225 // | |------------->|
6227 // | | SubFail | Duplicated action
6228 // | |<-------------|Ongoing transaction not found. This will result timer expiry and sending delete
6229 // | RESTNotif (fail)| |
6230 // |<----------------| |
6232 // | |------------->|
6235 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
6238 // | |------------->|
6241 // | |<-------------| Ongoing transaction not found.
6243 // | [SUBS DELETE] |
6246 //-----------------------------------------------------------------------------
6247 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
6248 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
6250 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6251 Counter{cRestSubReqFromXapp, 1},
6252 Counter{cRestSubRespToXapp, 1},
6253 Counter{cSubReqToE2, 1},
6254 Counter{cSubReqTimerExpiry, 2},
6255 Counter{cSubReReqToE2, 1},
6256 Counter{cSubRespFromE2, 1},
6257 Counter{cSubFailFromE2, 1},
6258 Counter{cRestSubFailNotifToXapp, 1},
6259 Counter{cRestSubDelReqFromXapp, 1},
6260 Counter{cRestSubDelRespToXapp, 1},
6261 Counter{cSubDelReqToE2, 1},
6262 Counter{cSubDelReqTimerExpiry, 2},
6263 Counter{cSubDelReReqToE2, 1},
6264 Counter{cSubDelRespFromE2, 2},
6267 const subReqCount int = 1
6270 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6271 restSubId := xappConn1.SendRESTSubsReq(t, params)
6273 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6275 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6276 // No transaction exist for this response which will result resending original request
6277 e2termConn1.SendSubsResp(t, crereq, cremsg)
6279 _, cremsg = e2termConn1.RecvSubsReq(t)
6281 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6283 // Subscription already created in E2 Node.
6284 fparams := &teststube2ap.E2StubSubsFailParams{}
6286 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6287 e2termConn1.SendSubsFail(t, fparams, cremsg)
6289 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6290 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6292 // Resending happens because there no transaction
6293 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6294 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6296 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6297 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6299 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6301 // Wait that subs is cleaned
6302 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6304 xappConn1.TestMsgChanEmpty(t)
6305 e2termConn1.TestMsgChanEmpty(t)
6306 mainCtrl.wait_registry_empty(t, 10)
6307 mainCtrl.VerifyAllClean(t)
6308 mainCtrl.VerifyCounterValues(t)
6311 //-----------------------------------------------------------------------------
6312 // TestRESTUnpackSubscriptionFailureDecodeFail
6315 // +-------+ +---------+ +---------+
6316 // | xapp | | submgr | | e2term |
6317 // +-------+ +---------+ +---------+
6320 // |---------------->| |
6322 // | RESTSubResp | |
6323 // |<----------------| |
6326 // | |------------->|
6328 // | | SubFail | ASN.1 decode fails
6329 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
6332 // | |------------->|
6334 // | | SubFail | Duplicated action
6335 // | |<-------------|
6336 // | RESTNotif (fail)| |
6337 // |<----------------| |
6339 // | [SUBS DELETE] |
6342 //-----------------------------------------------------------------------------
6343 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
6344 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
6346 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6347 Counter{cRestSubReqFromXapp, 1},
6348 Counter{cRestSubRespToXapp, 1},
6349 Counter{cSubReqToE2, 1},
6350 Counter{cSubReqTimerExpiry, 1},
6351 Counter{cSubReReqToE2, 1},
6352 Counter{cSubFailFromE2, 2},
6353 Counter{cRestSubFailNotifToXapp, 1},
6354 Counter{cRestSubDelReqFromXapp, 1},
6355 Counter{cRestSubDelRespToXapp, 1},
6358 const subReqCount int = 1
6361 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6362 restSubId := xappConn1.SendRESTSubsReq(t, params)
6364 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6366 // Decode of this response fails which will result resending original request
6367 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
6369 _, cremsg = e2termConn1.RecvSubsReq(t)
6371 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6373 // Subscription already created in E2 Node.
6374 fparams := &teststube2ap.E2StubSubsFailParams{}
6376 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6377 e2termConn1.SendSubsFail(t, fparams, cremsg)
6379 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6380 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6382 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6384 // Wait that subs is cleaned
6385 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6387 xappConn1.TestMsgChanEmpty(t)
6388 e2termConn1.TestMsgChanEmpty(t)
6389 mainCtrl.wait_registry_empty(t, 10)
6390 mainCtrl.VerifyAllClean(t)
6391 mainCtrl.VerifyCounterValues(t)
6394 //-----------------------------------------------------------------------------
6395 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
6398 // +-------+ +---------+ +---------+
6399 // | xapp | | submgr | | e2term |
6400 // +-------+ +---------+ +---------+
6403 // |---------------->| |
6405 // | RESTSubResp | |
6406 // |<----------------| |
6409 // | |------------->|
6411 // | | SubFail | Unknown instanceId
6412 // | |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
6415 // | |------------->|
6417 // | | SubFail | Duplicated action
6418 // | |<-------------|No valid subscription found with subIds [0]. This will result timer expiry and sending delete
6419 // | RESTNotif (fail)| |
6420 // |<----------------| |
6422 // | |------------->|
6425 // | |<-------------|
6427 // | [SUBS DELETE] |
6430 //-----------------------------------------------------------------------------
6431 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
6432 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
6433 const subReqCount int = 1
6435 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6436 Counter{cRestSubReqFromXapp, 1},
6437 Counter{cRestSubRespToXapp, 1},
6438 Counter{cSubReqToE2, 1},
6439 Counter{cSubReqTimerExpiry, 2},
6440 Counter{cSubReReqToE2, 1},
6441 Counter{cSubFailFromE2, 2},
6442 Counter{cRestSubFailNotifToXapp, 1},
6443 Counter{cRestSubDelReqFromXapp, 1},
6444 Counter{cRestSubDelRespToXapp, 1},
6445 Counter{cSubDelReqToE2, 1},
6446 Counter{cSubDelRespFromE2, 1},
6450 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6451 restSubId := xappConn1.SendRESTSubsReq(t, params)
6453 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6455 // Unknown instanceId 0 in this response which will result resending original request
6456 fparams := &teststube2ap.E2StubSubsFailParams{}
6458 fparams.Fail.RequestId.InstanceId = 0
6459 e2termConn1.SendSubsFail(t, fparams, cremsg)
6461 _, cremsg = e2termConn1.RecvSubsReq(t)
6463 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6465 // Subscription already created in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
6466 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6467 e2termConn1.SendSubsFail(t, fparams, cremsg)
6469 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6470 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6472 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6473 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6475 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6477 // Wait that subs is cleaned
6478 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6480 xappConn1.TestMsgChanEmpty(t)
6481 e2termConn1.TestMsgChanEmpty(t)
6482 mainCtrl.wait_registry_empty(t, 10)
6483 mainCtrl.VerifyAllClean(t)
6484 mainCtrl.VerifyCounterValues(t)
6487 //-----------------------------------------------------------------------------
6488 // TestRESTUnpackSubscriptionFailureNoTransaction
6491 // +-------+ +---------+ +---------+
6492 // | xapp | | submgr | | e2term |
6493 // +-------+ +---------+ +---------+
6496 // |---------------->| |
6498 // | RESTSubResp | |
6499 // |<----------------| |
6502 // | |------------->|
6504 // | | SubFail | No transaction for the response
6505 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
6508 // | |------------->|
6510 // | | SubFail | Duplicated action
6511 // | |<-------------| Ongoing transaction not found. This will result timer expiry and sending delete
6512 // | RESTNotif (fail)| |
6513 // |<----------------| |
6515 // | |------------->|
6518 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
6521 // | |------------->|
6524 // | |<-------------| Ongoing transaction not found.
6526 // | [SUBS DELETE] |
6529 //-----------------------------------------------------------------------------
6530 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
6531 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
6532 const subReqCount int = 1
6534 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6535 Counter{cRestSubReqFromXapp, 1},
6536 Counter{cRestSubRespToXapp, 1},
6537 Counter{cSubReqToE2, 1},
6538 Counter{cSubReqTimerExpiry, 2},
6539 Counter{cSubReReqToE2, 1},
6540 Counter{cSubFailFromE2, 2},
6541 Counter{cRestSubFailNotifToXapp, 1},
6542 Counter{cRestSubDelReqFromXapp, 1},
6543 Counter{cRestSubDelRespToXapp, 1},
6544 Counter{cSubDelReqToE2, 1},
6545 Counter{cSubDelReqTimerExpiry, 2},
6546 Counter{cSubDelReReqToE2, 1},
6547 Counter{cSubDelRespFromE2, 2},
6551 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6552 restSubId := xappConn1.SendRESTSubsReq(t, params)
6554 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6556 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6558 // No transaction exist for this response which will result resending original request
6559 fparams := &teststube2ap.E2StubSubsFailParams{}
6561 e2termConn1.SendSubsFail(t, fparams, cremsg)
6563 _, cremsg = e2termConn1.RecvSubsReq(t)
6565 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6567 // Subscription already created in E2 Node.
6568 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6569 e2termConn1.SendSubsFail(t, fparams, cremsg)
6571 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6572 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6574 // Resending happens because there no transaction
6575 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6576 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6578 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6579 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6581 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6583 // Wait that subs is cleaned
6584 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6586 xappConn1.TestMsgChanEmpty(t)
6587 e2termConn1.TestMsgChanEmpty(t)
6588 mainCtrl.wait_registry_empty(t, 10)
6589 mainCtrl.VerifyAllClean(t)
6590 mainCtrl.VerifyCounterValues(t)
6593 //-----------------------------------------------------------------------------
6594 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
6597 // +-------+ +---------+ +---------+
6598 // | xapp | | submgr | | e2term |
6599 // +-------+ +---------+ +---------+
6601 // | [SUBS CREATE] |
6604 // | RESTSubDelReq | |
6605 // |---------------->| |
6607 // | RESTSubDelResp | |
6608 // |<----------------| |
6611 // | |------------->|
6613 // | | SubDelResp | ASN.1 decode fails.
6614 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
6617 // | |------------->|
6619 // | | SubDelFail | Subscription does exist any more in E2 node
6620 // | |<-------------|
6622 // | [SUBS DELETE] |
6625 //-----------------------------------------------------------------------------
6626 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
6627 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail")
6629 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6630 Counter{cRestSubReqFromXapp, 1},
6631 Counter{cRestSubRespToXapp, 1},
6632 Counter{cSubReqToE2, 1},
6633 Counter{cSubRespFromE2, 1},
6634 Counter{cRestSubNotifToXapp, 1},
6635 Counter{cRestSubDelReqFromXapp, 1},
6636 Counter{cRestSubDelRespToXapp, 1},
6637 Counter{cSubDelReqToE2, 1},
6638 Counter{cSubDelReqTimerExpiry, 1},
6639 Counter{cSubDelReReqToE2, 1},
6640 Counter{cSubDelFailFromE2, 1},
6641 Counter{cSubDelRespFromE2, 1},
6645 var params *teststube2ap.RESTSubsReqParams = nil
6646 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6649 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6651 // E2t: Receive 1st SubsDelReq
6652 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6654 // Decode of this response fails which will result resending original request
6655 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_RESP)
6657 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6658 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6660 // Subscription does not exist in in E2 Node.
6661 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6663 // Wait that subs is cleaned
6664 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6666 xappConn1.TestMsgChanEmpty(t)
6667 e2termConn1.TestMsgChanEmpty(t)
6668 mainCtrl.wait_registry_empty(t, 10)
6669 mainCtrl.VerifyAllClean(t)
6670 mainCtrl.VerifyCounterValues(t)
6673 //-----------------------------------------------------------------------------
6674 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
6677 // +-------+ +---------+ +---------+
6678 // | xapp | | submgr | | e2term |
6679 // +-------+ +---------+ +---------+
6681 // | [SUBS CREATE] |
6684 // | RESTSubDelReq | |
6685 // |---------------->| |
6687 // | RESTSubDelResp | |
6688 // |<----------------| |
6691 // | |------------->|
6693 // | | SubDelResp | Unknown instanceId
6694 // | |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
6697 // | |------------->|
6699 // | | SubDelFail | Subscription does exist any more in E2 node
6700 // | |<-------------|
6702 // | [SUBS DELETE] |
6704 //-----------------------------------------------------------------------------
6705 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
6706 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId")
6708 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6709 Counter{cRestSubReqFromXapp, 1},
6710 Counter{cRestSubRespToXapp, 1},
6711 Counter{cSubReqToE2, 1},
6712 Counter{cSubRespFromE2, 1},
6713 Counter{cRestSubNotifToXapp, 1},
6714 Counter{cRestSubDelReqFromXapp, 1},
6715 Counter{cRestSubDelRespToXapp, 1},
6716 Counter{cSubDelReqToE2, 1},
6717 Counter{cSubDelReqTimerExpiry, 1},
6718 Counter{cSubDelReReqToE2, 1},
6719 Counter{cSubDelRespFromE2, 1},
6720 Counter{cSubDelFailFromE2, 1},
6724 var params *teststube2ap.RESTSubsReqParams = nil
6725 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6728 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6730 // E2t: Receive 1st SubsDelReq
6731 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6733 // Unknown instanceId in this response which will result resending original request
6734 delreq.RequestId.InstanceId = 0
6735 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6737 // E2t: Receive 2nd SubsDelReq
6738 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6740 // Subscription does not exist in in E2 Node.
6741 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6743 // Wait that subs is cleaned
6744 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6746 xappConn1.TestMsgChanEmpty(t)
6747 e2termConn1.TestMsgChanEmpty(t)
6748 mainCtrl.wait_registry_empty(t, 10)
6749 mainCtrl.VerifyAllClean(t)
6750 mainCtrl.VerifyCounterValues(t)
6753 //-----------------------------------------------------------------------------
6754 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
6757 // +-------+ +---------+ +---------+
6758 // | xapp | | submgr | | e2term |
6759 // +-------+ +---------+ +---------+
6761 // | [SUBS CREATE] |
6764 // | RESTSubDelReq | |
6765 // |---------------->| |
6767 // | RESTSubDelResp | |
6768 // |<----------------| |
6771 // | |------------->|
6773 // | | SubDelResp | No transaction for the response
6774 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
6777 // | |------------->|
6779 // | | SubDelFail | Subscription does exist any more in E2 node
6780 // | |<-------------| Ongoing transaction not found. This will result timer expiry
6782 // | [SUBS DELETE] |
6784 //-----------------------------------------------------------------------------
6785 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
6786 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction")
6788 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6789 Counter{cRestSubReqFromXapp, 1},
6790 Counter{cRestSubRespToXapp, 1},
6791 Counter{cSubReqToE2, 1},
6792 Counter{cSubRespFromE2, 1},
6793 Counter{cRestSubNotifToXapp, 1},
6794 Counter{cRestSubDelReqFromXapp, 1},
6795 Counter{cRestSubDelRespToXapp, 1},
6796 Counter{cSubDelReqToE2, 1},
6797 Counter{cSubDelReqTimerExpiry, 2},
6798 Counter{cSubDelReReqToE2, 1},
6799 Counter{cSubDelRespFromE2, 1},
6800 Counter{cSubDelFailFromE2, 1},
6804 var params *teststube2ap.RESTSubsReqParams = nil
6805 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6808 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6810 // E2t: Receive 1st SubsDelReq
6811 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6813 mainCtrl.MakeTransactionNil(t, e2SubsId)
6815 // No transaction exist for this response which will result resending original request
6816 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6818 // E2t: Receive 2nd SubsDelReq
6819 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6821 // Subscription does not exist in in E2 Node.
6822 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6824 // Wait that subs is cleaned
6825 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6827 xappConn1.TestMsgChanEmpty(t)
6828 e2termConn1.TestMsgChanEmpty(t)
6829 mainCtrl.wait_registry_empty(t, 10)
6830 mainCtrl.VerifyAllClean(t)
6831 mainCtrl.VerifyCounterValues(t)
6834 //-----------------------------------------------------------------------------
6835 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
6838 // +-------+ +---------+ +---------+
6839 // | xapp | | submgr | | e2term |
6840 // +-------+ +---------+ +---------+
6842 // | [SUBS CREATE] |
6845 // | RESTSubDelReq | |
6846 // |---------------->| |
6848 // | RESTSubDelResp | |
6849 // |<----------------| |
6852 // | |------------->|
6854 // | | SubDelFail | ASN.1 decode fails
6855 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
6858 // | |------------->|
6860 // | | SubDelFail | Subscription does exist any more in E2 node
6861 // | |<-------------|
6863 // | [SUBS DELETE] |
6865 //-----------------------------------------------------------------------------
6866 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
6867 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail")
6869 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6870 Counter{cRestSubReqFromXapp, 1},
6871 Counter{cRestSubRespToXapp, 1},
6872 Counter{cSubReqToE2, 1},
6873 Counter{cSubRespFromE2, 1},
6874 Counter{cRestSubNotifToXapp, 1},
6875 Counter{cRestSubDelReqFromXapp, 1},
6876 Counter{cRestSubDelRespToXapp, 1},
6877 Counter{cSubDelReqToE2, 1},
6878 Counter{cSubDelReqTimerExpiry, 1},
6879 Counter{cSubDelReReqToE2, 1},
6880 Counter{cSubDelFailFromE2, 2},
6884 var params *teststube2ap.RESTSubsReqParams = nil
6885 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6888 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6890 // E2t: Receive 1st SubsDelReq
6891 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6893 // Decode of this response fails which will result resending original request
6894 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
6896 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6897 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6899 // Subscription does not exist in in E2 Node.
6900 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6902 // Wait that subs is cleaned
6903 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6905 xappConn1.TestMsgChanEmpty(t)
6906 e2termConn1.TestMsgChanEmpty(t)
6907 mainCtrl.wait_registry_empty(t, 10)
6908 mainCtrl.VerifyAllClean(t)
6909 mainCtrl.VerifyCounterValues(t)
6912 //-----------------------------------------------------------------------------
6913 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
6916 // +-------+ +---------+ +---------+
6917 // | xapp | | submgr | | e2term |
6918 // +-------+ +---------+ +---------+
6920 // | [SUBS CREATE] |
6923 // | RESTSubDelReq | |
6924 // |---------------->| |
6926 // | RESTSubDelResp | |
6927 // |<----------------| |
6930 // | |------------->|
6932 // | | SubDelFail | Unknown instanceId
6933 // | |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
6936 // | |------------->|
6938 // | | SubDelFail | Subscription does exist any more in E2 node
6939 // | |<-------------| No valid subscription found with subIds [0].
6941 // | [SUBS DELETE] |
6943 //-----------------------------------------------------------------------------
6944 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
6945 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId")
6947 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6948 Counter{cRestSubReqFromXapp, 1},
6949 Counter{cRestSubRespToXapp, 1},
6950 Counter{cSubReqToE2, 1},
6951 Counter{cSubRespFromE2, 1},
6952 Counter{cRestSubNotifToXapp, 1},
6953 Counter{cRestSubDelReqFromXapp, 1},
6954 Counter{cRestSubDelRespToXapp, 1},
6955 Counter{cSubDelReqToE2, 1},
6956 Counter{cSubDelReqTimerExpiry, 1},
6957 Counter{cSubDelReReqToE2, 1},
6958 Counter{cSubDelFailFromE2, 2},
6962 var params *teststube2ap.RESTSubsReqParams = nil
6963 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6966 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6968 // E2t: Receive 1st SubsDelReq
6969 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6971 // Unknown instanceId 0 in this response which will result resending original request
6972 delreq.RequestId.InstanceId = 0
6973 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6975 // E2t: Receive 2nd SubsDelReq
6976 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6978 // Subscription does not exist in in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
6979 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6981 // Wait that subs is cleaned
6982 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6984 xappConn1.TestMsgChanEmpty(t)
6985 e2termConn1.TestMsgChanEmpty(t)
6986 mainCtrl.wait_registry_empty(t, 10)
6987 mainCtrl.VerifyAllClean(t)
6988 mainCtrl.VerifyCounterValues(t)
6991 //-----------------------------------------------------------------------------
6992 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
6995 // +-------+ +---------+ +---------+
6996 // | xapp | | submgr | | e2term |
6997 // +-------+ +---------+ +---------+
6999 // | [SUBS CREATE] |
7002 // | RESTSubDelReq | |
7003 // |---------------->| |
7005 // | RESTSubDelResp | |
7006 // |<----------------| |
7009 // | |------------->|
7011 // | | SubDelFail | No transaction for the response
7012 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
7015 // | |------------->|
7017 // | | SubDelFail | Subscription does exist any more in E2 node
7018 // | |<-------------| Ongoing transaction not found. This will result timer expiry
7020 // | [SUBS DELETE] |
7022 //-----------------------------------------------------------------------------
7023 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
7024 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction")
7026 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7027 Counter{cRestSubReqFromXapp, 1},
7028 Counter{cRestSubRespToXapp, 1},
7029 Counter{cSubReqToE2, 1},
7030 Counter{cSubRespFromE2, 1},
7031 Counter{cRestSubNotifToXapp, 1},
7032 Counter{cRestSubDelReqFromXapp, 1},
7033 Counter{cRestSubDelRespToXapp, 1},
7034 Counter{cSubDelReqToE2, 1},
7035 Counter{cSubDelReqTimerExpiry, 2},
7036 Counter{cSubDelReReqToE2, 1},
7037 Counter{cSubDelFailFromE2, 2},
7041 var params *teststube2ap.RESTSubsReqParams = nil
7042 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
7045 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7047 // E2t: Receive 1st SubsDelReq
7048 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7050 mainCtrl.MakeTransactionNil(t, e2SubsId)
7052 // No transaction exist for this response which will result resending original request
7053 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
7055 // E2t: Receive 2nd SubsDelReq
7056 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
7058 // Subscription does not exist in in E2 Node.
7059 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
7061 // Wait that subs is cleaned
7062 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
7064 xappConn1.TestMsgChanEmpty(t)
7065 e2termConn1.TestMsgChanEmpty(t)
7066 mainCtrl.wait_registry_empty(t, 10)
7067 mainCtrl.VerifyAllClean(t)
7068 mainCtrl.VerifyCounterValues(t)
7071 //-----------------------------------------------------------------------------
7072 // TestRESTSubReqFailAsn1PackSubReqError
7075 // +-------+ +---------+ +---------+
7076 // | xapp | | submgr | | e2term |
7077 // +-------+ +---------+ +---------+
7080 // |---------------->| |
7082 // | RESTSubResp | |
7083 // |<----------------| |
7085 // | ASN.1 encode fails |
7088 // | |------------->|
7091 // | |<-------------|
7095 // |<----------------| |
7097 // | [SUBS DELETE] |
7100 //-----------------------------------------------------------------------------
7101 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
7103 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7104 Counter{cRestSubReqFromXapp, 1},
7105 Counter{cRestSubRespToXapp, 1},
7106 Counter{cRestSubFailNotifToXapp, 1},
7107 Counter{cRestSubDelReqFromXapp, 1},
7108 Counter{cRestSubDelRespToXapp, 1},
7111 const subReqCount int = 1
7113 var params *teststube2ap.RESTSubsReqParams = nil
7114 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
7115 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
7118 restSubId := xappConn1.SendRESTSubsReq(t, params)
7119 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
7121 // E2t: Receive SubsDelReq
7122 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7124 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7125 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
7127 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
7129 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7131 // Wait that subs is cleaned
7132 waitSubsCleanup(t, e2SubsId, 10)
7133 mainCtrl.VerifyAllClean(t)
7134 mainCtrl.VerifyCounterValues(t)
7137 func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
7138 CaseBegin("TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction")
7140 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7141 Counter{cRestSubReqFromXapp, 2},
7142 Counter{cRestSubRespToXapp, 2},
7143 Counter{cSubReqToE2, 2},
7144 Counter{cSubReqTimerExpiry, 1},
7145 Counter{cSubRespFromE2, 1},
7146 Counter{cRestSubNotifToXapp, 1},
7147 Counter{cRestSubFailNotifToXapp, 1},
7148 Counter{cRestSubDelReqFromXapp, 1},
7149 Counter{cSubDelReqToE2, 1},
7150 Counter{cSubDelRespFromE2, 1},
7151 Counter{cRestSubDelRespToXapp, 1},
7154 const e2Timeout int64 = 1
7155 const e2RetryCount int64 = 0
7156 const routingNeeded bool = false
7159 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7160 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7163 restSubId := xappConn1.SendRESTSubsReq(t, params)
7164 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
7166 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7167 xappConn1.ExpectRESTNotification(t, restSubId)
7168 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
7169 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7170 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7173 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7174 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7175 params.SetSubscriptionID(&restSubId)
7176 params.SetTimeToWait("w200ms")
7177 restSubId = xappConn1.SendRESTSubsReq(t, params)
7178 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
7180 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
7181 xappConn1.ExpectRESTNotification(t, restSubId)
7182 // SubsResp is missing, e2SubsId will be 0
7183 zeroE2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7184 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", zeroE2SubsId)
7187 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7188 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7189 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7191 waitSubsCleanup(t, e2SubsId, 10)
7192 mainCtrl.VerifyAllClean(t)
7193 mainCtrl.VerifyCounterValues(t)
7196 //-----------------------------------------------------------------------------
7197 // TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle
7200 // +-------+ +---------+ +---------+
7201 // | xapp | | submgr | | e2term |
7202 // +-------+ +---------+ +---------+
7205 // |---------------->| |
7207 // | RESTSubResp | |
7208 // |<----------------| |
7210 // | |------------->|
7213 // | |<-------------|
7216 // |<----------------| |
7219 // |---------------->| |
7221 // | RESTSubResp | |
7222 // |<----------------| |
7224 // | |------------->|
7226 // | Submgr restart |
7228 // | RESTSubDelReq | |
7229 // |---------------->| |
7232 // | |------------->|
7235 // | |<-------------|
7237 // | RESTSubDelResp | |
7238 // |<----------------| |
7240 //-----------------------------------------------------------------------------
7242 func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
7243 CaseBegin("TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle")
7245 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7246 Counter{cRestSubReqFromXapp, 2},
7247 Counter{cRestSubRespToXapp, 2},
7248 Counter{cSubReqToE2, 2},
7249 Counter{cSubRespFromE2, 1},
7250 Counter{cRestSubNotifToXapp, 1},
7251 Counter{cRestSubDelReqFromXapp, 1},
7252 Counter{cSubDelReqToE2, 1},
7253 Counter{cSubDelRespFromE2, 1},
7254 Counter{cRestSubDelRespToXapp, 1},
7257 const e2Timeout int64 = 1
7258 const e2RetryCount int64 = 0
7259 const routingNeeded bool = false
7262 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7263 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7264 // Create subscription
7265 restSubId := xappConn1.SendRESTSubsReq(t, params)
7266 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
7268 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7269 xappConn1.ExpectRESTNotification(t, restSubId)
7270 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
7271 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7272 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7274 // Check subscription
7275 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
7278 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7279 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7280 params.SetSubscriptionID(&restSubId)
7281 params.SetTimeToWait("w200ms")
7282 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
7283 restSubId = xappConn1.SendRESTSubsReq(t, params)
7284 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
7286 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
7287 mainCtrl.SetResetTestFlag(t, false)
7289 // SubsResp is missing due to submgr restart
7291 mainCtrl.SimulateRestart(t)
7292 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
7294 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
7295 // That needs to be completed before successful subscription query is possible
7296 <-time.After(time.Second * 1)
7298 // Check subscription
7299 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
7301 // Delete subscription
7302 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7303 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7304 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7306 //Wait that subs is cleaned
7307 waitSubsCleanup(t, e2SubsId, 10)
7309 mainCtrl.VerifyCounterValues(t)
7310 mainCtrl.VerifyAllClean(t)
7313 ////////////////////////////////////////////////////////////////////////////////////
7314 // Services for UT cases
7315 ////////////////////////////////////////////////////////////////////////////////////
7316 const subReqCount int = 1
7317 const host string = "localhost"
7319 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
7321 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
7323 restSubId := fromXappConn.SendRESTSubsReq(t, params)
7324 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
7326 crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
7327 fromXappConn.ExpectRESTNotification(t, restSubId)
7328 toE2termConn.SendSubsResp(t, crereq1, cremsg1)
7329 e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
7330 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7332 return restSubId, e2SubsId
7335 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
7337 params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
7339 params.SetMeid(meid)
7341 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
7342 restSubId := xappConn2.SendRESTSubsReq(t, params)
7343 xappConn2.ExpectRESTNotification(t, restSubId)
7344 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
7345 e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
7346 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7348 return restSubId, e2SubsId
7351 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
7353 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7354 restSubId := xappConn1.SendRESTSubsReq(t, params)
7355 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
7357 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7358 xappConn1.ExpectRESTNotification(t, restSubId)
7359 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
7360 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7361 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7363 return restSubId, e2SubsId
7366 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
7367 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7368 restSubId := xappConn1.SendRESTSubsReq(t, params)
7370 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7371 fparams1 := &teststube2ap.E2StubSubsFailParams{}
7372 fparams1.Set(crereq1)
7373 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
7375 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
7376 xappConn1.ExpectRESTNotification(t, restSubId)
7377 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
7378 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7379 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
7381 return restSubId, e2SubsId
7384 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
7385 fromXappConn.SendRESTSubsDelReq(t, restSubId)
7386 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
7387 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
7390 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
7391 xappConn1.SendRESTSubsDelReq(t, restSubId)
7392 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7393 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7396 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
7397 xappConn2.SendRESTSubsDelReq(t, restSubId)
7398 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7399 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7402 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
7403 resp, _ := xapp.Subscription.QuerySubscriptions()
7404 assert.Equal(t, e2SubsId, resp[0].SubscriptionID)
7405 assert.Equal(t, meid, resp[0].Meid)
7406 assert.Equal(t, endpoint, resp[0].ClientEndpoint)
7409 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
7410 //Wait that subs is cleaned
7411 mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
7413 xappConn1.TestMsgChanEmpty(t)
7414 xappConn2.TestMsgChanEmpty(t)
7415 e2termConn1.TestMsgChanEmpty(t)
7416 mainCtrl.wait_registry_empty(t, timeout)
7419 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
7421 var e2SubsId []uint32
7423 for i := 0; i < count; i++ {
7424 xapp.Logger.Debug("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
7425 crereq, cremsg := toE2termConn.RecvSubsReq(t)
7426 fromXappConn.ExpectRESTNotification(t, restSubId)
7427 toE2termConn.SendSubsResp(t, crereq, cremsg)
7428 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
7429 e2SubsId = append(e2SubsId, instanceId)
7430 xapp.Logger.Debug("TEST: %v", e2SubsId)
7431 xapp.Logger.Debug("TEST: %d ===================================== END CRE ============================================", i+1)
7432 <-time.After(100 * time.Millisecond)
7437 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
7439 for i := 0; i < len(e2SubsIds); i++ {
7440 xapp.Logger.Debug("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
7441 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
7442 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
7443 <-time.After(1 * time.Second)
7444 xapp.Logger.Debug("TEST: %d ===================================== END DEL ============================================", i+1)
7445 <-time.After(100 * time.Millisecond)
7448 // Wait that subs is cleaned
7449 for i := 0; i < len(e2SubsIds); i++ {
7450 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)