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)
692 mainCtrl.VerifyCounterValues(t)
695 //-----------------------------------------------------------------------------
696 // TestSubMergeDelAndRouteUpdateNok
698 // +-------+ +-------+ +---------+ +---------+
699 // | xapp2 | | xapp1 | | submgr | | e2term |
700 // +-------+ +-------+ +---------+ +---------+
705 // | |------------->| |
708 // | | |------------->|
710 // | | |<-------------|
712 // | |<-------------| |
715 // |--------------------------->| |
718 // |<---------------------------| |
720 // | | SubDelReq 1 | |
721 // | |------------->| |
722 // | | | RouteUpdate |
723 // | | |-----> rtmgr |
725 // | | | RouteUpdate |
726 // | | | status:400 |
727 // | | |<----- rtmgr |
729 // | | SubDelResp 1 | |
730 // | |<-------------| |
733 // |--------------------------->| |
735 // | | | SubDelReq 2 |
736 // | | |------------->|
738 // | | | SubDelReq 2 |
739 // | | |------------->|
741 // | SubDelResp 2 | |
742 // |<---------------------------| |
744 //-----------------------------------------------------------------------------
745 func TestSubMergeDelAndRouteUpdateNok(t *testing.T) {
746 CaseBegin("TestSubMergeDelAndRouteUpdateNok")
748 // Init counter check
749 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
750 Counter{cSubReqFromXapp, 2},
751 Counter{cMergedSubscriptions, 1},
752 Counter{cSubReqToE2, 1},
753 Counter{cSubRespFromE2, 1},
754 Counter{cSubRespToXapp, 2},
755 Counter{cSubDelReqFromXapp, 2},
756 Counter{cRouteDeleteUpdateFail, 1},
757 Counter{cSubDelReqToE2, 1},
758 Counter{cSubDelRespFromE2, 1},
759 Counter{cSubDelRespToXapp, 2},
760 Counter{cUnmergedSubscriptions, 1},
764 rparams1 := &teststube2ap.E2StubSubsReqParams{}
766 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
767 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
768 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
769 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
772 rparams2 := &teststube2ap.E2StubSubsReqParams{}
774 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
775 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
777 resp, _ := xapp.Subscription.QuerySubscriptions()
778 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
779 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
780 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
783 waiter := rtmgrHttp.AllocNextEvent(false)
784 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
787 xappConn1.RecvSubsDelResp(t, deltrans1)
790 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
791 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
792 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
793 xappConn2.RecvSubsDelResp(t, deltrans2)
794 //Wait that subs is cleaned
795 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
797 xappConn1.TestMsgChanEmpty(t)
798 xappConn2.TestMsgChanEmpty(t)
799 e2termConn1.TestMsgChanEmpty(t)
800 mainCtrl.wait_registry_empty(t, 10)
802 mainCtrl.VerifyCounterValues(t)
805 //-----------------------------------------------------------------------------
807 //-----------------------------------------------------------------------------
808 // TestSubReqAndSubDelOk
811 // +-------+ +---------+ +---------+
812 // | xapp | | submgr | | e2term |
813 // +-------+ +---------+ +---------+
816 // |------------->| |
819 // | |------------->|
822 // | |<-------------|
825 // |<-------------| |
829 // |------------->| |
832 // | |------------->|
835 // | |<-------------|
838 // |<-------------| |
840 //-----------------------------------------------------------------------------
841 func TestSubReqAndSubDelOk(t *testing.T) {
842 CaseBegin("TestSubReqAndSubDelOk")
844 // Init counter check
845 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
846 Counter{cSubReqFromXapp, 1},
847 Counter{cSubReqToE2, 1},
848 Counter{cSubRespFromE2, 1},
849 Counter{cSubRespToXapp, 1},
850 Counter{cSubDelReqFromXapp, 1},
851 Counter{cSubDelReqToE2, 1},
852 Counter{cSubDelRespFromE2, 1},
853 Counter{cSubDelRespToXapp, 1},
856 cretrans := xappConn1.SendSubsReq(t, nil, nil)
857 crereq, cremsg := e2termConn1.RecvSubsReq(t)
858 e2termConn1.SendSubsResp(t, crereq, cremsg)
859 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
861 resp, _ := xapp.Subscription.QuerySubscriptions()
862 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
863 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
864 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
866 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
867 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
869 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
870 xappConn1.RecvSubsDelResp(t, deltrans)
872 //Wait that subs is cleaned
873 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
875 xappConn1.TestMsgChanEmpty(t)
876 xappConn2.TestMsgChanEmpty(t)
877 e2termConn1.TestMsgChanEmpty(t)
878 mainCtrl.wait_registry_empty(t, 10)
880 mainCtrl.VerifyCounterValues(t)
883 //-----------------------------------------------------------------------------
884 // TestSubReqRetransmission
887 // +-------+ +---------+ +---------+
888 // | xapp | | submgr | | e2term |
889 // +-------+ +---------+ +---------+
892 // |------------->| |
895 // | |------------->|
899 // |------------->| |
902 // | |<-------------|
905 // |<-------------| |
910 //-----------------------------------------------------------------------------
911 func TestSubReqRetransmission(t *testing.T) {
912 CaseBegin("TestSubReqRetransmission")
915 cretrans := xappConn1.SendSubsReq(t, nil, nil)
916 crereq, cremsg := e2termConn1.RecvSubsReq(t)
918 seqBef := mainCtrl.get_msgcounter(t)
919 xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq
920 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
922 // hack as there is no real way to see has message be handled.
923 // Previuos counter check just tells that is has been received by submgr
924 // --> artificial delay
925 <-time.After(1 * time.Second)
926 e2termConn1.SendSubsResp(t, crereq, cremsg)
927 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
930 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
931 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
932 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
933 xappConn1.RecvSubsDelResp(t, deltrans)
935 //Wait that subs is cleaned
936 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
938 xappConn1.TestMsgChanEmpty(t)
939 xappConn2.TestMsgChanEmpty(t)
940 e2termConn1.TestMsgChanEmpty(t)
941 mainCtrl.wait_registry_empty(t, 10)
944 //-----------------------------------------------------------------------------
945 // TestSubDelReqRetransmission
948 // +-------+ +---------+ +---------+
949 // | xapp | | submgr | | e2term |
950 // +-------+ +---------+ +---------+
956 // |------------->| |
959 // | |------------->|
964 // |------------->| |
967 // | |<-------------|
970 // |<-------------| |
972 //-----------------------------------------------------------------------------
973 func TestSubDelReqRetransmission(t *testing.T) {
974 CaseBegin("TestSubDelReqRetransmission")
977 cretrans := xappConn1.SendSubsReq(t, nil, nil)
978 crereq, cremsg := e2termConn1.RecvSubsReq(t)
979 e2termConn1.SendSubsResp(t, crereq, cremsg)
980 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
983 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
984 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
986 seqBef := mainCtrl.get_msgcounter(t)
987 xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq
988 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
990 // hack as there is no real way to see has message be handled.
991 // Previuos counter check just tells that is has been received by submgr
992 // --> artificial delay
993 <-time.After(1 * time.Second)
995 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
996 xappConn1.RecvSubsDelResp(t, deltrans)
998 //Wait that subs is cleaned
999 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1001 xappConn1.TestMsgChanEmpty(t)
1002 xappConn2.TestMsgChanEmpty(t)
1003 e2termConn1.TestMsgChanEmpty(t)
1004 mainCtrl.wait_registry_empty(t, 10)
1007 //-----------------------------------------------------------------------------
1008 // TestSubDelReqCollision
1011 // +-------+ +---------+ +---------+
1012 // | xapp | | submgr | | e2term |
1013 // +-------+ +---------+ +---------+
1015 // | [SUBS CREATE] |
1018 // | SubDelReq 1 | |
1019 // |------------->| |
1021 // | | SubDelReq 1 |
1022 // | |------------->|
1024 // | SubDelReq 2 | |
1027 // |------------->| |
1029 // | | SubDelResp 1 |
1030 // | |<-------------|
1032 // | SubDelResp 1 | |
1033 // |<-------------| |
1035 // | SubDelResp 2 | |
1036 // |<-------------| |
1038 //-----------------------------------------------------------------------------
1040 func TestSubDelReqCollision(t *testing.T) {
1041 CaseBegin("TestSubDelReqCollision")
1044 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1045 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1046 e2termConn1.SendSubsResp(t, crereq, cremsg)
1047 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1050 xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1051 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1053 // Subs Delete colliding
1054 seqBef := mainCtrl.get_msgcounter(t)
1055 deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1056 xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq
1057 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
1059 // hack as there is no real way to see has message be handled.
1060 // Previuos counter check just tells that is has been received by submgr
1061 // --> artificial delay
1062 <-time.After(1 * time.Second)
1064 // Del resp for first and second
1065 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1067 // don't care in which order responses are received
1068 xappConn1.RecvSubsDelResp(t, nil)
1069 xappConn1.RecvSubsDelResp(t, nil)
1071 //Wait that subs is cleaned
1072 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1074 xappConn1.TestMsgChanEmpty(t)
1075 xappConn2.TestMsgChanEmpty(t)
1076 e2termConn1.TestMsgChanEmpty(t)
1077 mainCtrl.wait_registry_empty(t, 10)
1080 //-----------------------------------------------------------------------------
1081 // TestSubReqAndSubDelOkTwoParallel
1084 // +-------+ +-------+ +---------+ +---------+
1085 // | xapp | | xapp | | submgr | | e2term |
1086 // +-------+ +-------+ +---------+ +---------+
1091 // | |------------->| |
1094 // | | |------------->|
1097 // |------------------------>| |
1100 // | | |------------->|
1103 // | | |<-------------|
1105 // | |<-------------| |
1108 // | | |<-------------|
1110 // |<------------------------| |
1112 // | | [SUBS 1 DELETE] |
1114 // | | [SUBS 2 DELETE] |
1117 //-----------------------------------------------------------------------------
1119 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
1120 CaseBegin("TestSubReqAndSubDelOkTwoParallel")
1123 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1125 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1126 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1129 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1132 rparams2.Req.EventTriggerDefinition.Data.Length = 1
1133 rparams2.Req.EventTriggerDefinition.Data.Data = make([]uint8, rparams2.Req.EventTriggerDefinition.Data.Length)
1134 rparams2.Req.EventTriggerDefinition.Data.Data[0] = 2
1136 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1137 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1140 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1141 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1144 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1145 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1148 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1149 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1150 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1151 xappConn1.RecvSubsDelResp(t, deltrans1)
1152 //Wait that subs is cleaned
1153 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1156 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1157 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1158 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1159 xappConn2.RecvSubsDelResp(t, deltrans2)
1160 //Wait that subs is cleaned
1161 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1163 xappConn1.TestMsgChanEmpty(t)
1164 xappConn2.TestMsgChanEmpty(t)
1165 e2termConn1.TestMsgChanEmpty(t)
1166 mainCtrl.wait_registry_empty(t, 10)
1169 //-----------------------------------------------------------------------------
1170 // TestSameSubsDiffRan
1171 // Same subscription to different RANs
1174 // +-------+ +---------+ +---------+
1175 // | xapp | | submgr | | e2term |
1176 // +-------+ +---------+ +---------+
1181 // |------------->| |
1184 // | |------------->|
1186 // | | SubResp(r1) |
1187 // | |<-------------|
1189 // | SubResp(r1) | |
1190 // |<-------------| |
1193 // |------------->| |
1196 // | |------------->|
1198 // | | SubResp(r2) |
1199 // | |<-------------|
1201 // | SubResp(r2) | |
1202 // |<-------------| |
1204 // | [SUBS r1 DELETE] |
1206 // | [SUBS r2 DELETE] |
1209 //-----------------------------------------------------------------------------
1210 func TestSameSubsDiffRan(t *testing.T) {
1211 CaseBegin("TestSameSubsDiffRan")
1214 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1215 xappConn1.SendSubsReq(t, nil, cretrans1)
1216 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1217 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1218 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1221 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
1222 xappConn1.SendSubsReq(t, nil, cretrans2)
1223 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1224 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1225 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1228 deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1229 xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
1230 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1231 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1232 xappConn1.RecvSubsDelResp(t, deltrans1)
1233 //Wait that subs is cleaned
1234 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1237 deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
1238 xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
1239 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1240 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1241 xappConn1.RecvSubsDelResp(t, deltrans2)
1242 //Wait that subs is cleaned
1243 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1245 xappConn1.TestMsgChanEmpty(t)
1246 xappConn2.TestMsgChanEmpty(t)
1247 e2termConn1.TestMsgChanEmpty(t)
1248 mainCtrl.wait_registry_empty(t, 10)
1251 //-----------------------------------------------------------------------------
1252 // TestSubReqRetryInSubmgr
1255 // +-------+ +---------+ +---------+
1256 // | xapp | | submgr | | e2term |
1257 // +-------+ +---------+ +---------+
1260 // |------------->| |
1263 // | |------------->|
1267 // | |------------->|
1270 // | |<-------------|
1273 // |<-------------| |
1275 // | [SUBS DELETE] |
1278 //-----------------------------------------------------------------------------
1280 func TestSubReqRetryInSubmgr(t *testing.T) {
1281 CaseBegin("TestSubReqRetryInSubmgr start")
1283 // Init counter check
1284 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1285 Counter{cSubReqFromXapp, 1},
1286 Counter{cSubReqToE2, 1},
1287 Counter{cSubReqTimerExpiry, 1},
1288 Counter{cSubReReqToE2, 1},
1289 Counter{cSubRespFromE2, 1},
1290 Counter{cSubRespToXapp, 1},
1291 Counter{cSubDelReqFromXapp, 1},
1292 Counter{cSubDelReqToE2, 1},
1293 Counter{cSubDelRespFromE2, 1},
1294 Counter{cSubDelRespToXapp, 1},
1297 // Xapp: Send SubsReq
1298 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1300 // E2t: Receive 1st SubsReq
1301 e2termConn1.RecvSubsReq(t)
1303 // E2t: Receive 2nd SubsReq and send SubsResp
1304 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1305 e2termConn1.SendSubsResp(t, crereq, cremsg)
1307 // Xapp: Receive SubsResp
1308 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1310 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1311 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1312 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1313 xappConn1.RecvSubsDelResp(t, deltrans)
1315 // Wait that subs is cleaned
1316 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1318 xappConn1.TestMsgChanEmpty(t)
1319 xappConn2.TestMsgChanEmpty(t)
1320 e2termConn1.TestMsgChanEmpty(t)
1321 mainCtrl.wait_registry_empty(t, 10)
1323 mainCtrl.VerifyCounterValues(t)
1326 //-----------------------------------------------------------------------------
1327 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
1330 // +-------+ +---------+ +---------+
1331 // | xapp | | submgr | | e2term |
1332 // +-------+ +---------+ +---------+
1335 // |------------->| |
1338 // | |------------->|
1342 // | |------------->|
1345 // | |------------->|
1348 // | |<-------------|
1351 //-----------------------------------------------------------------------------
1352 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
1353 CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
1355 // Init counter check
1356 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1357 Counter{cSubReqFromXapp, 1},
1358 Counter{cSubReqToE2, 1},
1359 Counter{cSubReReqToE2, 1},
1360 Counter{cSubReqTimerExpiry, 2},
1361 Counter{cSubDelReqToE2, 1},
1362 Counter{cSubDelRespFromE2, 1},
1365 // Xapp: Send SubsReq
1366 xappConn1.SendSubsReq(t, nil, nil)
1368 // E2t: Receive 1st SubsReq
1369 e2termConn1.RecvSubsReq(t)
1371 // E2t: Receive 2nd SubsReq
1372 e2termConn1.RecvSubsReq(t)
1374 // E2t: Send receive SubsDelReq and send SubsResp
1375 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1376 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1378 // Wait that subs is cleaned
1379 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 10)
1381 xappConn1.TestMsgChanEmpty(t)
1382 xappConn2.TestMsgChanEmpty(t)
1383 e2termConn1.TestMsgChanEmpty(t)
1384 mainCtrl.wait_registry_empty(t, 10)
1386 mainCtrl.VerifyCounterValues(t)
1389 //-----------------------------------------------------------------------------
1390 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
1393 // +-------+ +---------+ +---------+
1394 // | xapp | | submgr | | e2term |
1395 // +-------+ +---------+ +---------+
1398 // |------------->| |
1401 // | |------------->|
1405 // | |------------->|
1408 // | |------------->|
1412 // | |------------->|
1416 //-----------------------------------------------------------------------------
1418 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
1419 CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
1421 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1422 Counter{cSubReqFromXapp, 1},
1423 Counter{cSubReqToE2, 1},
1424 Counter{cSubReReqToE2, 1},
1425 Counter{cSubReqTimerExpiry, 2},
1426 Counter{cSubDelReqToE2, 1},
1427 Counter{cSubDelReReqToE2, 1},
1428 Counter{cSubDelReqTimerExpiry, 2},
1431 // Xapp: Send SubsReq
1432 xappConn1.SendSubsReq(t, nil, nil)
1434 // E2t: Receive 1st SubsReq
1435 e2termConn1.RecvSubsReq(t)
1437 // E2t: Receive 2nd SubsReq
1438 e2termConn1.RecvSubsReq(t)
1440 // E2t: Receive 1st SubsDelReq
1441 e2termConn1.RecvSubsDelReq(t)
1443 // E2t: Receive 2nd SubsDelReq
1444 delreq, _ := e2termConn1.RecvSubsDelReq(t)
1446 // Wait that subs is cleaned
1447 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 15)
1449 xappConn1.TestMsgChanEmpty(t)
1450 xappConn2.TestMsgChanEmpty(t)
1451 e2termConn1.TestMsgChanEmpty(t)
1452 mainCtrl.wait_registry_empty(t, 10)
1454 mainCtrl.VerifyCounterValues(t)
1457 //-----------------------------------------------------------------------------
1458 // TestSubReqSubFailRespInSubmgr
1461 // +-------+ +---------+ +---------+
1462 // | xapp | | submgr | | e2term |
1463 // +-------+ +---------+ +---------+
1466 // |------------->| |
1469 // | |------------->|
1472 // | |<-------------|
1475 // |<-------------| |
1478 //-----------------------------------------------------------------------------
1480 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1481 CaseBegin("TestSubReqSubFailRespInSubmgr start")
1483 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1484 Counter{cSubReqFromXapp, 1},
1485 Counter{cSubReqToE2, 1},
1486 Counter{cSubFailFromE2, 1},
1487 Counter{cSubFailToXapp, 1},
1490 // Xapp: Send SubsReq
1491 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1493 // E2t: Receive SubsReq and send SubsFail (first)
1494 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1495 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1496 fparams1.Set(crereq1)
1497 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1499 // Xapp: Receive SubsFail
1500 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
1502 // Wait that subs is cleaned
1503 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1505 xappConn1.TestMsgChanEmpty(t)
1506 xappConn2.TestMsgChanEmpty(t)
1507 e2termConn1.TestMsgChanEmpty(t)
1508 mainCtrl.wait_registry_empty(t, 10)
1510 mainCtrl.VerifyCounterValues(t)
1513 //-----------------------------------------------------------------------------
1514 // TestSubDelReqRetryInSubmgr
1517 // +-------+ +---------+ +---------+
1518 // | xapp | | submgr | | e2term |
1519 // +-------+ +---------+ +---------+
1521 // | [SUBS CREATE] |
1525 // |------------->| |
1528 // | |------------->|
1531 // | |------------->|
1534 // | |<-------------|
1537 // |<-------------| |
1539 //-----------------------------------------------------------------------------
1541 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1543 CaseBegin("TestSubDelReqRetryInSubmgr start")
1546 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1547 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1548 e2termConn1.SendSubsResp(t, crereq, cremsg)
1549 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1552 // Xapp: Send SubsDelReq
1553 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1555 // E2t: Receive 1st SubsDelReq
1556 e2termConn1.RecvSubsDelReq(t)
1558 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1559 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1560 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1562 // Xapp: Receive SubsDelResp
1563 xappConn1.RecvSubsDelResp(t, deltrans)
1565 // Wait that subs is cleaned
1566 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1568 xappConn1.TestMsgChanEmpty(t)
1569 xappConn2.TestMsgChanEmpty(t)
1570 e2termConn1.TestMsgChanEmpty(t)
1571 mainCtrl.wait_registry_empty(t, 10)
1574 //-----------------------------------------------------------------------------
1575 // TestSubDelReqTwoRetriesNoRespInSubmgr
1578 // +-------+ +---------+ +---------+
1579 // | xapp | | submgr | | e2term |
1580 // +-------+ +---------+ +---------+
1582 // | [SUBS CREATE] |
1586 // |------------->| |
1589 // | |------------->|
1592 // | |------------->|
1596 // |<-------------| |
1598 //-----------------------------------------------------------------------------
1600 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1602 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
1605 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1606 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1607 e2termConn1.SendSubsResp(t, crereq, cremsg)
1608 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1611 // Xapp: Send SubsDelReq
1612 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1614 // E2t: Receive 1st SubsDelReq
1615 e2termConn1.RecvSubsDelReq(t)
1617 // E2t: Receive 2nd SubsDelReq
1618 e2termConn1.RecvSubsDelReq(t)
1620 // Xapp: Receive SubsDelResp
1621 xappConn1.RecvSubsDelResp(t, deltrans)
1623 // Wait that subs is cleaned
1624 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1626 xappConn1.TestMsgChanEmpty(t)
1627 xappConn2.TestMsgChanEmpty(t)
1628 e2termConn1.TestMsgChanEmpty(t)
1629 mainCtrl.wait_registry_empty(t, 10)
1632 //-----------------------------------------------------------------------------
1633 // TestSubDelReqSubDelFailRespInSubmgr
1636 // +-------+ +---------+ +---------+
1637 // | xapp | | submgr | | e2term |
1638 // +-------+ +---------+ +---------+
1640 // | [SUBS CREATE] |
1644 // |------------->| |
1647 // | |------------->|
1650 // | |<-------------|
1653 // |<-------------| |
1656 //-----------------------------------------------------------------------------
1658 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1659 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1661 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1662 Counter{cSubReqFromXapp, 1},
1663 Counter{cSubReqToE2, 1},
1664 Counter{cSubRespFromE2, 1},
1665 Counter{cSubRespToXapp, 1},
1666 Counter{cSubDelReqFromXapp, 1},
1667 Counter{cSubDelReqToE2, 1},
1668 Counter{cSubDelFailFromE2, 1},
1669 Counter{cSubDelRespToXapp, 1},
1673 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1674 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1675 e2termConn1.SendSubsResp(t, crereq, cremsg)
1676 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1678 // Xapp: Send SubsDelReq
1679 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1681 // E2t: Send receive SubsDelReq and send SubsDelFail
1682 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1683 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1685 // Xapp: Receive SubsDelResp
1686 xappConn1.RecvSubsDelResp(t, deltrans)
1688 // Wait that subs is cleaned
1689 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1691 xappConn1.TestMsgChanEmpty(t)
1692 xappConn2.TestMsgChanEmpty(t)
1693 e2termConn1.TestMsgChanEmpty(t)
1694 mainCtrl.wait_registry_empty(t, 10)
1696 mainCtrl.VerifyCounterValues(t)
1699 //-----------------------------------------------------------------------------
1700 // TestSubReqAndSubDelOkSameAction
1703 // +-------+ +-------+ +---------+ +---------+
1704 // | xapp2 | | xapp1 | | submgr | | e2term |
1705 // +-------+ +-------+ +---------+ +---------+
1710 // | |------------->| |
1713 // | | |------------->|
1715 // | | |<-------------|
1717 // | |<-------------| |
1720 // |--------------------------->| |
1723 // |<---------------------------| |
1725 // | | SubDelReq 1 | |
1726 // | |------------->| |
1728 // | | SubDelResp 1 | |
1729 // | |<-------------| |
1731 // | SubDelReq 2 | |
1732 // |--------------------------->| |
1734 // | | | SubDelReq 2 |
1735 // | | |------------->|
1737 // | | | SubDelReq 2 |
1738 // | | |------------->|
1740 // | SubDelResp 2 | |
1741 // |<---------------------------| |
1743 //-----------------------------------------------------------------------------
1744 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
1745 CaseBegin("TestSubReqAndSubDelOkSameAction")
1747 // Init counter check
1748 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1749 Counter{cSubReqFromXapp, 2},
1750 Counter{cSubReqToE2, 1},
1751 Counter{cSubRespFromE2, 1},
1752 Counter{cSubRespToXapp, 2},
1753 Counter{cMergedSubscriptions, 1},
1754 Counter{cUnmergedSubscriptions, 1},
1755 Counter{cSubDelReqFromXapp, 2},
1756 Counter{cSubDelReqToE2, 1},
1757 Counter{cSubDelRespFromE2, 1},
1758 Counter{cSubDelRespToXapp, 2},
1762 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1764 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1765 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1766 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1767 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1770 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1772 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1773 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1775 resp, _ := xapp.Subscription.QuerySubscriptions()
1776 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1777 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1778 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
1781 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1782 xappConn1.RecvSubsDelResp(t, deltrans1)
1785 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1786 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1787 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1788 xappConn2.RecvSubsDelResp(t, deltrans2)
1789 //Wait that subs is cleaned
1790 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1792 xappConn1.TestMsgChanEmpty(t)
1793 xappConn2.TestMsgChanEmpty(t)
1794 e2termConn1.TestMsgChanEmpty(t)
1795 mainCtrl.wait_registry_empty(t, 10)
1797 mainCtrl.VerifyCounterValues(t)
1800 //-----------------------------------------------------------------------------
1801 // TestSubReqAndSubDelOkSameActionParallel
1804 // +-------+ +-------+ +---------+ +---------+
1805 // | xapp2 | | xapp1 | | submgr | | e2term |
1806 // +-------+ +-------+ +---------+ +---------+
1811 // | |------------->| |
1814 // | | |------------->|
1816 // |--------------------------->| |
1818 // | | |<-------------|
1820 // | |<-------------| |
1823 // |<---------------------------| |
1825 // | | SubDelReq 1 | |
1826 // | |------------->| |
1828 // | | SubDelResp 1 | |
1829 // | |<-------------| |
1831 // | SubDelReq 2 | |
1832 // |--------------------------->| |
1834 // | | | SubDelReq 2 |
1835 // | | |------------->|
1837 // | | | SubDelReq 2 |
1838 // | | |------------->|
1840 // | SubDelResp 2 | |
1841 // |<---------------------------| |
1843 //-----------------------------------------------------------------------------
1844 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1845 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1848 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1850 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1851 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1854 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1856 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1859 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1860 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1863 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1866 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1867 xappConn1.RecvSubsDelResp(t, deltrans1)
1870 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1871 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1872 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1873 xappConn2.RecvSubsDelResp(t, deltrans2)
1875 //Wait that subs is cleaned
1876 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1878 xappConn1.TestMsgChanEmpty(t)
1879 xappConn2.TestMsgChanEmpty(t)
1880 e2termConn1.TestMsgChanEmpty(t)
1881 mainCtrl.wait_registry_empty(t, 10)
1884 //-----------------------------------------------------------------------------
1885 // TestSubReqAndSubDelNokSameActionParallel
1888 // +-------+ +-------+ +---------+ +---------+
1889 // | xapp2 | | xapp1 | | submgr | | e2term |
1890 // +-------+ +-------+ +---------+ +---------+
1895 // | |------------->| |
1898 // | | |------------->|
1900 // |--------------------------->| |
1902 // | | |<-------------|
1905 // | |<-------------| |
1908 // |<---------------------------| |
1910 //-----------------------------------------------------------------------------
1911 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1912 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1915 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1917 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1919 // E2t: Receive SubsReq (first)
1920 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1923 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1925 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1926 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1927 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1929 // E2t: send SubsFail (first)
1930 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1931 fparams1.Set(crereq1)
1932 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1935 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1937 xappConn2.RecvSubsFail(t, cretrans2)
1939 //Wait that subs is cleaned
1940 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1942 xappConn1.TestMsgChanEmpty(t)
1943 xappConn2.TestMsgChanEmpty(t)
1944 e2termConn1.TestMsgChanEmpty(t)
1945 mainCtrl.wait_registry_empty(t, 10)
1948 //-----------------------------------------------------------------------------
1949 // TestSubReqAndSubDelNoAnswerSameActionParallel
1952 // +-------+ +-------+ +---------+ +---------+
1953 // | xapp2 | | xapp1 | | submgr | | e2term |
1954 // +-------+ +-------+ +---------+ +---------+
1959 // | |------------->| |
1962 // | | |------------->|
1964 // |--------------------------->| |
1967 // | | |------------->|
1970 // | | | SubDelReq |
1971 // | | |------------->|
1973 // | | | SubDelResp |
1974 // | | |<-------------|
1976 //-----------------------------------------------------------------------------
1977 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1978 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1981 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1983 xappConn1.SendSubsReq(t, rparams1, nil)
1985 crereq1, _ := e2termConn1.RecvSubsReq(t)
1988 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1990 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1991 xappConn2.SendSubsReq(t, rparams2, nil)
1992 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1994 //Req1 (retransmitted)
1995 e2termConn1.RecvSubsReq(t)
1997 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1998 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2000 //Wait that subs is cleaned
2001 mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10)
2003 xappConn1.TestMsgChanEmpty(t)
2004 xappConn2.TestMsgChanEmpty(t)
2005 e2termConn1.TestMsgChanEmpty(t)
2006 mainCtrl.wait_registry_empty(t, 15)
2009 //----------------------------- Policy cases ---------------------------------
2010 //-----------------------------------------------------------------------------
2011 // TestSubReqPolicyAndSubDelOk
2014 // +-------+ +---------+ +---------+
2015 // | xapp | | submgr | | e2term |
2016 // +-------+ +---------+ +---------+
2019 // |------------->| |
2022 // | |------------->|
2025 // | |<-------------|
2028 // |<-------------| |
2032 // |------------->| |
2035 // | |------------->|
2038 // | |<-------------|
2041 // |<-------------| |
2043 //-----------------------------------------------------------------------------
2044 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
2045 CaseBegin("TestSubReqAndSubDelOk")
2047 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2049 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
2050 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2052 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2053 e2termConn1.SendSubsResp(t, crereq, cremsg)
2054 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2055 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2056 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2058 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2059 xappConn1.RecvSubsDelResp(t, deltrans)
2061 //Wait that subs is cleaned
2062 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2064 xappConn1.TestMsgChanEmpty(t)
2065 xappConn2.TestMsgChanEmpty(t)
2066 e2termConn1.TestMsgChanEmpty(t)
2067 mainCtrl.wait_registry_empty(t, 10)
2070 //-----------------------------------------------------------------------------
2071 // TestSubReqPolicyChangeAndSubDelOk
2074 // +-------+ +---------+ +---------+
2075 // | xapp | | submgr | | e2term |
2076 // +-------+ +---------+ +---------+
2079 // |------------->| |
2082 // | |------------->|
2085 // | |<-------------|
2088 // |<-------------| |
2091 // |------------->| |
2094 // | |------------->|
2097 // | |<-------------|
2100 // |<-------------| |
2103 // |------------->| |
2106 // | |------------->|
2109 // | |<-------------|
2112 // |<-------------| |
2114 //-----------------------------------------------------------------------------
2116 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
2117 CaseBegin("TestSubReqAndSubDelOk")
2119 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2121 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
2122 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2124 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2125 e2termConn1.SendSubsResp(t, crereq, cremsg)
2126 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2129 rparams1.Req.RequestId.InstanceId = e2SubsId
2130 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
2131 xappConn1.SendSubsReq(t, rparams1, cretrans)
2133 crereq, cremsg = e2termConn1.RecvSubsReq(t)
2134 e2termConn1.SendSubsResp(t, crereq, cremsg)
2135 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2136 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2137 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2139 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2140 xappConn1.RecvSubsDelResp(t, deltrans)
2142 //Wait that subs is cleaned
2143 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2145 xappConn1.TestMsgChanEmpty(t)
2146 xappConn2.TestMsgChanEmpty(t)
2147 e2termConn1.TestMsgChanEmpty(t)
2148 mainCtrl.wait_registry_empty(t, 10)
2151 //-----------------------------------------------------------------------------
2152 // TestSubReqAndSubDelOkTwoE2termParallel
2155 // +-------+ +---------+ +---------+ +---------+
2156 // | xapp | | submgr | | e2term1 | | e2term2 |
2157 // +-------+ +---------+ +---------+ +---------+
2162 // |------------->| | |
2165 // | |------------->| |
2168 // |------------->| | |
2171 // | |---------------------------->|
2174 // | |<-------------| |
2176 // |<-------------| | |
2178 // | |<----------------------------|
2180 // |<-------------| | |
2182 // | [SUBS 1 DELETE] | |
2184 // | [SUBS 2 DELETE] | |
2187 //-----------------------------------------------------------------------------
2188 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
2189 CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
2192 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
2193 xappConn1.SendSubsReq(t, nil, cretrans1)
2194 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2196 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
2197 xappConn1.SendSubsReq(t, nil, cretrans2)
2198 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
2201 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2202 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2205 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
2206 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
2209 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2210 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2211 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2212 xappConn1.RecvSubsDelResp(t, deltrans1)
2213 //Wait that subs is cleaned
2214 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
2217 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
2218 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
2219 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
2220 xappConn1.RecvSubsDelResp(t, deltrans2)
2221 //Wait that subs is cleaned
2222 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2224 xappConn1.TestMsgChanEmpty(t)
2225 xappConn2.TestMsgChanEmpty(t)
2226 e2termConn1.TestMsgChanEmpty(t)
2227 e2termConn2.TestMsgChanEmpty(t)
2228 mainCtrl.wait_registry_empty(t, 10)
2231 //-----------------------------------------------------------------------------
2232 // TestSubReqInsertAndSubDelOk
2235 // +-------+ +---------+ +---------+
2236 // | xapp | | submgr | | e2term |
2237 // +-------+ +---------+ +---------+
2240 // |------------->| |
2243 // | |------------->|
2246 // | |<-------------|
2249 // |<-------------| |
2253 // |------------->| |
2256 // | |------------->|
2259 // | |<-------------|
2262 // |<-------------| |
2264 //-----------------------------------------------------------------------------
2265 func TestSubReqInsertAndSubDelOk(t *testing.T) {
2266 CaseBegin("TestInsertSubReqAndSubDelOk")
2268 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2270 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeInsert
2271 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2273 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2274 e2termConn1.SendSubsResp(t, crereq, cremsg)
2275 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2276 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2277 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2279 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2280 xappConn1.RecvSubsDelResp(t, deltrans)
2282 //Wait that subs is cleaned
2283 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2285 xappConn1.TestMsgChanEmpty(t)
2286 xappConn2.TestMsgChanEmpty(t)
2287 e2termConn1.TestMsgChanEmpty(t)
2288 mainCtrl.wait_registry_empty(t, 10)
2291 //-----------------------------------------------------------------------------
2292 // TestSubReqRetransmissionWithSameSubIdDiffXid
2294 // This case simulates case where xApp restarts and starts sending same
2295 // subscription requests which have already subscribed successfully
2298 // +-------+ +---------+ +---------+
2299 // | xapp | | submgr | | e2term |
2300 // +-------+ +---------+ +---------+
2303 // |------------->| |
2306 // | |------------->|
2309 // | |<-------------|
2312 // |<-------------| |
2314 // | xApp restart | |
2317 // | (retrans with same xApp generated subid but diff xid)
2318 // |------------->| |
2321 // |<-------------| |
2323 // | [SUBS DELETE] |
2326 //-----------------------------------------------------------------------------
2327 func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) {
2328 CaseBegin("TestSubReqRetransmissionWithSameSubIdDiffXid")
2331 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2332 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2333 e2termConn1.SendSubsResp(t, crereq, cremsg)
2334 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2336 // xApp restart here
2337 // --> artificial delay
2338 <-time.After(1 * time.Second)
2341 cretrans = xappConn1.SendSubsReq(t, nil, nil) //Retransmitted SubReq
2342 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2345 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2346 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2347 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2348 xappConn1.RecvSubsDelResp(t, deltrans)
2350 //Wait that subs is cleaned
2351 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2353 xappConn1.TestMsgChanEmpty(t)
2354 xappConn2.TestMsgChanEmpty(t)
2355 e2termConn1.TestMsgChanEmpty(t)
2356 mainCtrl.wait_registry_empty(t, 10)
2359 //-----------------------------------------------------------------------------
2360 // TestSubReqNokAndSubDelOkWithRestartInMiddle
2363 // +-------+ +---------+ +---------+
2364 // | xapp | | submgr | | e2term |
2365 // +-------+ +---------+ +---------+
2368 // |------------->| |
2371 // | |------------->|
2376 // | Submgr restart |
2380 // | |------------->|
2383 // | |<-------------|
2386 //-----------------------------------------------------------------------------
2388 func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
2389 CaseBegin("TestSubReqNokAndSubDelOkWithRestartInMiddle")
2391 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
2392 xappConn1.SendSubsReq(t, nil, nil)
2393 e2termConn1.RecvSubsReq(t)
2394 mainCtrl.SetResetTestFlag(t, false)
2396 resp, _ := xapp.Subscription.QuerySubscriptions()
2397 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2398 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2399 e2SubsId := uint32(resp[0].SubscriptionID)
2400 t.Logf("e2SubsId = %v", e2SubsId)
2402 mainCtrl.SimulateRestart(t)
2403 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2405 // Submgr send delete for uncompleted subscription
2406 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2407 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2409 // Wait that subs is cleaned
2410 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2412 xappConn1.TestMsgChanEmpty(t)
2413 xappConn2.TestMsgChanEmpty(t)
2414 e2termConn1.TestMsgChanEmpty(t)
2415 mainCtrl.wait_registry_empty(t, 10)
2418 //-----------------------------------------------------------------------------
2419 // TestSubReqAndSubDelOkWithRestartInMiddle
2422 // +-------+ +---------+ +---------+
2423 // | xapp | | submgr | | e2term |
2424 // +-------+ +---------+ +---------+
2427 // |------------->| |
2430 // | |------------->|
2433 // | |<-------------|
2436 // |<-------------| |
2439 // | Submgr restart |
2442 // |------------->| |
2445 // | |------------->|
2448 // | |<-------------|
2451 // |<-------------| |
2453 //-----------------------------------------------------------------------------
2455 func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
2456 CaseBegin("TestSubReqAndSubDelOkWithRestartInMiddle")
2458 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2459 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2460 e2termConn1.SendSubsResp(t, crereq, cremsg)
2461 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2463 // Check subscription
2464 resp, _ := xapp.Subscription.QuerySubscriptions()
2465 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2466 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2467 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2469 mainCtrl.SimulateRestart(t)
2470 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2472 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
2473 // That needs to be completed before successful subscription query is possible
2474 <-time.After(time.Second * 1)
2476 // Check that subscription is restored correctly after restart
2477 resp, _ = xapp.Subscription.QuerySubscriptions()
2478 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2479 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2480 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2482 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2483 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2484 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2485 xappConn1.RecvSubsDelResp(t, deltrans)
2487 //Wait that subs is cleaned
2488 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2490 xappConn1.TestMsgChanEmpty(t)
2491 xappConn2.TestMsgChanEmpty(t)
2492 e2termConn1.TestMsgChanEmpty(t)
2493 mainCtrl.wait_registry_empty(t, 10)
2496 //-----------------------------------------------------------------------------
2497 // TestSubReqAndSubDelOkSameActionWithRestartsInMiddle
2500 // +-------+ +-------+ +---------+ +---------+
2501 // | xapp2 | | xapp1 | | submgr | | e2term |
2502 // +-------+ +-------+ +---------+ +---------+
2507 // | |------------->| |
2510 // | | |------------->|
2512 // | | |<-------------|
2514 // | |<-------------| |
2517 // | submgr restart |
2522 // |--------------------------->| |
2525 // |<---------------------------| |
2527 // | | SubDelReq 1 | |
2528 // | |------------->| |
2530 // | | SubDelResp 1 | |
2531 // | |<-------------| |
2535 // | submgr restart |
2538 // | SubDelReq 2 | |
2539 // |--------------------------->| |
2541 // | | | SubDelReq 2 |
2542 // | | |------------->|
2544 // | | | SubDelReq 2 |
2545 // | | |------------->|
2547 // | SubDelResp 2 | |
2548 // |<---------------------------| |
2550 //-----------------------------------------------------------------------------
2552 func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
2553 CaseBegin("TestSubReqAndSubDelOkSameActionWithRestartsInMiddle")
2556 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2558 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2559 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2560 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2561 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2564 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2566 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2567 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
2569 // Check subscription
2570 resp, _ := xapp.Subscription.QuerySubscriptions()
2571 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2572 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2573 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2575 mainCtrl.SimulateRestart(t)
2576 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2578 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
2579 // That needs to be completed before successful subscription query is possible
2580 <-time.After(time.Second * 1)
2582 // Check that subscription is restored correctly after restart
2583 resp, _ = xapp.Subscription.QuerySubscriptions()
2584 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2585 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2586 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2589 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2590 xapp.Logger.Debug("xappConn1.RecvSubsDelResp")
2591 xappConn1.RecvSubsDelResp(t, deltrans1)
2592 xapp.Logger.Debug("xappConn1.RecvSubsDelResp received")
2594 mainCtrl.SimulateRestart(t)
2595 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2597 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
2598 // Submgr need be ready before successful subscription deletion is possible
2599 <-time.After(time.Second * 1)
2602 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
2603 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2605 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2606 xappConn2.RecvSubsDelResp(t, deltrans2)
2608 //Wait that subs is cleaned
2609 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2611 xappConn1.TestMsgChanEmpty(t)
2612 xappConn2.TestMsgChanEmpty(t)
2613 e2termConn1.TestMsgChanEmpty(t)
2614 mainCtrl.wait_registry_empty(t, 10)
2617 //*****************************************************************************
2618 // REST interface test cases
2619 //*****************************************************************************
2621 //-----------------------------------------------------------------------------
2622 // Test debug GET and POST requests
2625 // +-------+ +---------+
2626 // | user | | submgr |
2627 // +-------+ +---------+
2634 func TestGetSubscriptions(t *testing.T) {
2636 mainCtrl.sendGetRequest(t, "localhost:8088", "/ric/v1/subscriptions")
2639 func TestGetSymptomData(t *testing.T) {
2641 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/symptomdata")
2644 func TestPostdeleteSubId(t *testing.T) {
2646 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/deletesubid=1")
2649 func TestPostEmptyDb(t *testing.T) {
2651 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/emptydb")
2654 func TestGetRestSubscriptions(t *testing.T) {
2656 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/restsubscriptions")
2659 //-----------------------------------------------------------------------------
2660 // TestRESTSubReqAndRouteNok
2663 // +-------+ +---------+ +---------+
2664 // | xapp | | submgr | | rtmgr |
2665 // +-------+ +---------+ +---------+
2668 // |---------------->| |
2670 // | RESTSubResp | |
2671 // |<----------------| |
2672 // | | RouteCreate |
2673 // | |------------->|
2675 // | | RouteCreate |
2677 // | |(Bad request) |
2678 // | |<-------------|
2680 // |<----------------| |
2682 // | [SUBS INT DELETE] |
2684 // | RESTSubDelReq | |
2685 // |---------------->| |
2686 // | RESTSubDelResp | |
2687 // |<----------------| |
2689 //-----------------------------------------------------------------------------
2690 func TestRESTSubReqAndRouteNok(t *testing.T) {
2691 CaseBegin("TestRESTSubReqAndRouteNok")
2693 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2694 Counter{cRestSubReqFromXapp, 1},
2695 Counter{cRestSubRespToXapp, 1},
2696 Counter{cRouteCreateFail, 1},
2697 Counter{cRestSubFailNotifToXapp, 1},
2698 Counter{cRestSubDelReqFromXapp, 1},
2699 Counter{cRestSubDelRespToXapp, 1},
2702 const subReqCount int = 1
2704 // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
2705 waiter := rtmgrHttp.AllocNextSleep(50, false)
2706 newSubsId := mainCtrl.get_registry_next_subid(t)
2709 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2710 restSubId := xappConn1.SendRESTSubsReq(t, params)
2711 xappConn1.ExpectRESTNotificationNok(t, restSubId, "failAll")
2712 waiter.WaitResult(t)
2714 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2715 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
2718 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2720 // Wait that subs is cleaned
2721 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2722 waitSubsCleanup(t, e2SubsId, 10)
2723 mainCtrl.VerifyCounterValues(t)
2724 mainCtrl.VerifyAllClean(t)
2727 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
2728 CaseBegin("TestSubReqAndRouteUpdateNok")
2730 //Init counter check
2731 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2732 Counter{cRestSubReqFromXapp, 2},
2733 Counter{cRestSubRespToXapp, 2},
2734 Counter{cSubReqToE2, 1},
2735 Counter{cSubRespFromE2, 1},
2736 Counter{cRestSubNotifToXapp, 1},
2737 Counter{cRestSubFailNotifToXapp, 1},
2738 Counter{cRouteCreateUpdateFail, 1},
2739 Counter{cRestSubDelReqFromXapp, 2},
2740 Counter{cSubDelReqToE2, 1},
2741 Counter{cSubDelRespFromE2, 1},
2742 Counter{cRestSubDelRespToXapp, 2},
2745 var params *teststube2ap.RESTSubsReqParams = nil
2748 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2750 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2752 // xapp2 ROUTE creation shall fail with 400 from rtmgr -> submgr
2753 waiter := rtmgrHttp.AllocNextEvent(false)
2754 newSubsId := mainCtrl.get_registry_next_subid(t)
2755 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
2756 params.SetMeid("RAN_NAME_1")
2757 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2758 xapp.Logger.Debug("Send REST subscriber request for second subscriber : %v", restSubId2)
2759 xappConn2.ExpectRESTNotificationNok(t, restSubId2, "allFail")
2760 waiter.WaitResult(t)
2761 xappConn2.WaitRESTNotification(t, restSubId2)
2763 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2765 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2766 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
2768 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2769 //Wait that subs is cleaned
2770 waitSubsCleanup(t, e2SubsId, 10)
2772 mainCtrl.VerifyCounterValues(t)
2773 mainCtrl.VerifyAllClean(t)
2776 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
2777 CaseBegin("TestRESTSubDelReqAndRouteDeleteNok")
2779 // Init counter check
2780 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2781 Counter{cRestSubReqFromXapp, 1},
2782 Counter{cRestSubRespToXapp, 1},
2783 Counter{cSubReqToE2, 1},
2784 Counter{cSubRespFromE2, 1},
2785 Counter{cRestSubNotifToXapp, 1},
2786 Counter{cRestSubDelReqFromXapp, 1},
2787 Counter{cRouteDeleteFail, 1},
2788 Counter{cSubDelReqToE2, 1},
2789 Counter{cSubDelRespFromE2, 1},
2790 Counter{cRestSubDelRespToXapp, 1},
2793 var params *teststube2ap.RESTSubsReqParams = nil
2796 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2798 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2800 waiter := rtmgrHttp.AllocNextEvent(false)
2801 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2802 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2803 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2804 waiter.WaitResult(t)
2806 waitSubsCleanup(t, e2SubsId, 10)
2807 mainCtrl.VerifyCounterValues(t)
2808 mainCtrl.VerifyAllClean(t)
2811 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
2812 CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok")
2814 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2815 Counter{cRestSubReqFromXapp, 2},
2816 Counter{cMergedSubscriptions, 1},
2817 Counter{cRestSubRespToXapp, 2},
2818 Counter{cSubReqToE2, 1},
2819 Counter{cSubRespFromE2, 1},
2820 Counter{cRestSubNotifToXapp, 2},
2821 Counter{cRestSubDelReqFromXapp, 2},
2822 Counter{cRouteDeleteUpdateFail, 1},
2823 Counter{cSubDelReqToE2, 1},
2824 Counter{cSubDelRespFromE2, 1},
2825 Counter{cRestSubDelRespToXapp, 2},
2826 Counter{cUnmergedSubscriptions, 1},
2829 var params *teststube2ap.RESTSubsReqParams = nil
2832 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2834 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2835 restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1")
2837 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
2839 //Del1, this shall fail on rtmgr side
2840 waiter := rtmgrHttp.AllocNextEvent(false)
2841 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2842 waiter.WaitResult(t)
2844 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"})
2847 deleteXapp2Subscription(t, &restSubId2)
2849 waitSubsCleanup(t, e2SubsId2, 10)
2850 mainCtrl.VerifyCounterValues(t)
2851 mainCtrl.VerifyAllClean(t)
2854 //-----------------------------------------------------------------------------
2855 // TestRESTSubReqRetransmission
2858 // +-------+ +---------+ +---------+
2859 // | xapp | | submgr | | e2term |
2860 // +-------+ +---------+ +---------+
2862 // | RESTSubReq1 | |
2863 // |---------------->| |
2865 // | RESTSubResp | |
2866 // |<----------------| |
2868 // | |------------->|
2870 // | RESTSubReq2 | |
2872 // |---------------->| |
2873 // | RESTSubResp(201)| |
2874 // |<----------------| |
2877 // | |<-------------|
2879 // |<----------------| |
2881 // | [SUBS DELETE] |
2884 //-----------------------------------------------------------------------------
2886 func TestRESTSubReqRetransmission(t *testing.T) {
2887 CaseBegin("TestRESTSubReqRetransmission")
2889 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2890 Counter{cRestSubReqFromXapp, 2},
2891 Counter{cRestSubRespToXapp, 2},
2892 Counter{cSubReqToE2, 1},
2893 Counter{cSubRespFromE2, 1},
2894 Counter{cRestSubNotifToXapp, 1},
2895 Counter{cRestSubDelReqFromXapp, 1},
2896 Counter{cSubDelReqToE2, 1},
2897 Counter{cSubDelRespFromE2, 1},
2898 Counter{cRestSubDelRespToXapp, 1},
2900 // Retry/duplicate will get the same way as the first request.
2901 // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
2902 // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
2905 const subReqCount int = 1
2907 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2908 restSubId := xappConn1.SendRESTSubsReq(t, params)
2910 xappConn1.SendRESTSubsReq(t, params)
2911 <-time.After(time.Second * 1)
2913 xappConn1.WaitListedRestNotifications(t, []string{restSubId})
2915 // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
2916 // the order is not significant here.
2917 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2918 e2termConn1.SendSubsResp(t, crereq, cremsg)
2920 e2SubsId := <-xappConn1.ListedRESTNotifications
2922 xapp.Logger.Debug("TEST: XAPP notification received e2SubsId=%v", e2SubsId)
2925 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2926 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2927 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2929 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsId.E2SubsId}, 10)
2931 mainCtrl.VerifyCounterValues(t)
2932 mainCtrl.VerifyAllClean(t)
2935 //-----------------------------------------------------------------------------
2937 // +-------+ +---------+ +---------+ +---------+
2938 // | xapp | | submgr | | e2term | | rtmgr |
2939 // +-------+ +---------+ +---------+ +---------+
2941 // | RESTSubReq | | |
2942 // |---------------->| | |
2943 // | RESTSubResp | | |
2944 // |<----------------| | |
2945 // | | RouteCreate | |
2946 // | |--------------------------->|
2947 // | | RouteResponse| |
2948 // | |<---------------------------| // The order of these events may vary
2950 // | |------------->| | // The order of these events may vary
2952 // | |<-------------| |
2953 // | RESTNotif1 | | |
2954 // |<----------------| | |
2955 // | RESTSubReq | | |
2956 // | [RETRANS1] | | |
2957 // |---------------->| | |
2958 // | RESTNotif1 | | |
2959 // |<----------------| | |
2960 // | RESTSubReq | | |
2961 // | [RETRANS2] | | |
2962 // |---------------->| | |
2963 // | RESTNotif1 | | |
2964 // |<----------------| | |
2965 // | RESTSubDelReq | | |
2966 // |---------------->| | |
2967 // | | SubDelReq | |
2968 // | |------------->| |
2969 // | RESTSubDelResp| | |
2970 // |<----------------| | |
2971 // | | SubDelResp | |
2972 // | |<-------------| |
2975 //-----------------------------------------------------------------------------
2977 func TestRESTSubReqRetransmissionV2(t *testing.T) {
2978 CaseBegin("TestRESTSubReqRetransmissionV2")
2980 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2981 Counter{cRestSubReqFromXapp, 3},
2982 Counter{cDuplicateE2SubReq, 2},
2983 Counter{cRestSubRespToXapp, 3},
2984 Counter{cSubReqToE2, 1},
2985 Counter{cSubRespFromE2, 1},
2986 Counter{cRestSubNotifToXapp, 3},
2987 Counter{cRestSubDelReqFromXapp, 1},
2988 Counter{cSubDelReqToE2, 1},
2989 Counter{cSubDelRespFromE2, 1},
2990 Counter{cRestSubDelRespToXapp, 1},
2993 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2995 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2997 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2999 mainCtrl.WaitOngoingRequestMapEmpty()
3002 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
3004 assert.Equal(t, restSubId_resend, restSubId)
3006 mainCtrl.WaitOngoingRequestMapEmpty()
3009 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3011 assert.Equal(t, restSubId_resend2, restSubId)
3013 mainCtrl.WaitOngoingRequestMapEmpty()
3015 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3017 waitSubsCleanup(t, e2SubsId, 10)
3018 mainCtrl.VerifyCounterValues(t)
3019 mainCtrl.VerifyAllClean(t)
3022 //-----------------------------------------------------------------------------
3024 // +-------+ +---------+ +---------+ +---------+
3025 // | xapp | | submgr | | e2term | | rtmgr |
3026 // +-------+ +---------+ +---------+ +---------+
3028 // | RESTSubReq | | |
3029 // |---------------->| | |
3030 // | RESTSubResp | | |
3031 // |<----------------| | |
3032 // | | RouteCreate | |
3033 // | |--------------------------->|
3034 // | | RouteResponse| |
3035 // | |<---------------------------| // The order of these events may vary
3037 // | |------------->| | // The order of these events may vary
3039 // | |<-------------| |
3040 // | RESTNotif1 | | |
3041 // |<----------------| | |
3042 // | RESTSubReq | | |
3043 // | [RETRANS, with RESTsubsId] | |
3044 // |---------------->| | |
3045 // | RESTNotif1 | | |
3046 // |<----------------| | |
3047 // | RESTSubReq | | |
3048 // | [RETRANS, without RESTsubsId] | |
3049 // |---------------->| | |
3050 // | RESTNotif1 | | |
3051 // |<----------------| | |
3052 // | RESTSubDelReq | | |
3053 // |---------------->| | |
3054 // | | SubDelReq | |
3055 // | |------------->| |
3056 // | RESTSubDelResp| | |
3057 // |<----------------| | |
3058 // | | SubDelResp | |
3059 // | |<-------------| |
3062 //-----------------------------------------------------------------------------
3063 func TestRESTSubReqRetransmissionV3(t *testing.T) {
3064 CaseBegin("TestRESTSubReqRetransmissionV3")
3066 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3067 Counter{cRestSubReqFromXapp, 3},
3068 Counter{cDuplicateE2SubReq, 2},
3069 Counter{cRestSubRespToXapp, 3},
3070 Counter{cSubReqToE2, 1},
3071 Counter{cSubRespFromE2, 1},
3072 Counter{cRestSubNotifToXapp, 3},
3073 Counter{cRestSubDelReqFromXapp, 1},
3074 Counter{cSubDelReqToE2, 1},
3075 Counter{cSubDelRespFromE2, 1},
3076 Counter{cRestSubDelRespToXapp, 1},
3079 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3081 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3083 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3085 mainCtrl.WaitOngoingRequestMapEmpty()
3087 //1.st resend with subscription ID
3088 params.SetSubscriptionID(&restSubId)
3089 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
3091 assert.Equal(t, restSubId_resend, restSubId)
3093 mainCtrl.WaitOngoingRequestMapEmpty()
3095 //2.nd resend without subscription ID (faking app restart)
3096 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3097 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3099 assert.Equal(t, restSubId_resend2, restSubId)
3101 mainCtrl.WaitOngoingRequestMapEmpty()
3103 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3105 waitSubsCleanup(t, e2SubsId, 10)
3106 mainCtrl.VerifyCounterValues(t)
3107 mainCtrl.VerifyAllClean(t)
3110 //-----------------------------------------------------------------------------
3112 // +-------+ +---------+ +---------+ +---------+
3113 // | xapp | | submgr | | e2term | | rtmgr |
3114 // +-------+ +---------+ +---------+ +---------+
3116 // | RESTSubReq | | |
3117 // |---------------->| | |
3118 // | RESTSubResp | | |
3119 // |<----------------| | |
3120 // | | RouteCreate | |
3121 // | |--------------------------->|
3122 // | | RouteResponse| |
3123 // | |<---------------------------|
3125 // | |------------->| |
3127 // | |<-------------| |
3128 // | RESTNotif1 | | |
3129 // |<----------------| | |
3130 // | RESTSubReq | | |
3131 // | [with RestSUbsId + one additional e2 subDetail]
3132 // |---------------->| | |
3133 // | RESTNotif1 | | |
3134 // | [for initial e2 subDetail] | |
3135 // |<----------------| | |
3136 // | | RouteCreate | |
3137 // | |--------------------------->|
3138 // | | RouteResponse| |
3139 // | |<---------------------------|
3141 // | |------------->| |
3143 // | |<-------------| |
3144 // | RESTNotif1 | | |
3145 // |<----------------| | |
3146 // | RESTSubReq | | |
3147 // | [with RESTsubsId initial request] |
3148 // |---------------->| | |
3149 // | RESTNotif1 | | |
3150 // |<----------------| | |
3151 // | RESTSubDelReq | | |
3152 // |---------------->| | |
3153 // | RESTSubDelResp| | |
3154 // |<----------------| | |
3155 // | | SubDelReq | |
3156 // | |------------->| |
3157 // | | SubDelResp | |
3158 // | |<-------------| |
3159 // | | SubDelReq | |
3160 // | |------------->| |
3161 // | | SubDelResp | |
3162 // | |<-------------| |
3165 //-----------------------------------------------------------------------------
3167 func TestRESTSubReqRetransmissionV4(t *testing.T) {
3168 CaseBegin("TestRESTSubReqRetransmissionV4")
3170 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3171 Counter{cRestSubReqFromXapp, 3},
3172 Counter{cDuplicateE2SubReq, 2},
3173 Counter{cRestSubRespToXapp, 3},
3174 Counter{cSubReqToE2, 2},
3175 Counter{cSubRespFromE2, 2},
3176 Counter{cRestSubNotifToXapp, 4},
3177 Counter{cRestSubDelReqFromXapp, 1},
3178 Counter{cSubDelReqToE2, 2},
3179 Counter{cSubDelRespFromE2, 2},
3180 Counter{cRestSubDelRespToXapp, 1},
3183 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3185 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3187 mainCtrl.WaitOngoingRequestMapEmpty()
3189 // Send modified requst, this time with e2 subscriptions.
3190 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3191 params2.SetSubscriptionID(&restSubId)
3193 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3194 xappConn1.ExpectAnyNotification(t)
3195 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3196 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3197 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3198 assert.Equal(t, e2SubsId, e2SubsId1)
3200 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3202 xappConn1.DecrementRequestCount()
3203 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3204 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3205 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3206 assert.NotEqual(t, e2SubsId2, 0)
3208 mainCtrl.WaitOngoingRequestMapEmpty()
3210 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3211 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3212 params.SetSubscriptionID(&restSubId)
3213 xappConn1.ExpectAnyNotification(t)
3214 // Resend the original request again with only one e2 subscription (detail), this time with restsubsid
3215 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3216 assert.Equal(t, restSubId_resend, restSubId_resend2)
3218 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3219 assert.Equal(t, e2SubsId, e2SubsId1)
3221 mainCtrl.WaitOngoingRequestMapEmpty()
3223 // Delete both e2 subscriptions
3224 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3225 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3226 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3228 waitSubsCleanup(t, e2SubsId, 10)
3229 mainCtrl.VerifyCounterValues(t)
3230 mainCtrl.VerifyAllClean(t)
3233 //-----------------------------------------------------------------------------
3235 // +-------+ +---------+ +---------+ +---------+
3236 // | xapp | | submgr | | e2term | | rtmgr |
3237 // +-------+ +---------+ +---------+ +---------+
3239 // | RESTSubReq | | |
3240 // |---------------->| | |
3241 // | RESTSubResp | | |
3242 // |<----------------| | |
3243 // | | RouteCreate | |
3244 // | |--------------------------->|
3245 // | | RouteResponse| |
3246 // | |<---------------------------|
3248 // | |------------->| |
3250 // | |<-------------| |
3251 // | RESTNotif1 | | |
3252 // |<----------------| | |
3253 // | RESTSubReq | | |
3254 // | [with RestSUbsId + one additional e2 subDetail]
3255 // |---------------->| | |
3256 // | RESTNotif1 | | |
3257 // | [for initial e2 subDetail] | |
3258 // |<----------------| | |
3259 // | | RouteCreate | |
3260 // | |--------------------------->|
3261 // | | RouteResponse| |
3262 // | |<---------------------------|
3264 // | |------------->| |
3266 // | |<-------------| |
3267 // | RESTNotif1 | | |
3268 // |<----------------| | |
3269 // | RESTSubReq | | |
3270 // | [without RESTsubsId initial request] |
3271 // |---------------->| | |
3272 // | RESTNotif1 | | |
3273 // |<----------------| | |
3274 // | RESTSubDelReq | | |
3275 // |---------------->| | |
3276 // | RESTSubDelResp| | |
3277 // |<----------------| | |
3278 // | | SubDelReq | |
3279 // | |------------->| |
3280 // | | SubDelResp | |
3281 // | |<-------------| |
3282 // | | SubDelReq | |
3283 // | |------------->| |
3284 // | | SubDelResp | |
3285 // | |<-------------| |
3288 //-----------------------------------------------------------------------------
3290 func TestRESTSubReqRetransmissionV5(t *testing.T) {
3291 CaseBegin("TestRESTSubReqRetransmissionV5")
3293 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3294 Counter{cRestSubReqFromXapp, 3},
3295 Counter{cDuplicateE2SubReq, 2},
3296 Counter{cRestSubRespToXapp, 3},
3297 Counter{cSubReqToE2, 2},
3298 Counter{cSubRespFromE2, 2},
3299 Counter{cRestSubNotifToXapp, 4},
3300 Counter{cRestSubDelReqFromXapp, 1},
3301 Counter{cSubDelReqToE2, 2},
3302 Counter{cSubDelRespFromE2, 2},
3303 Counter{cRestSubDelRespToXapp, 1},
3306 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3308 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3310 mainCtrl.WaitOngoingRequestMapEmpty()
3312 // Send modified requst, this time with e2 subscriptions.
3313 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3314 params2.SetSubscriptionID(&restSubId)
3316 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3317 xappConn1.ExpectAnyNotification(t)
3318 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3319 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3321 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3322 assert.Equal(t, e2SubsId, e2SubsId1)
3323 // The first E2 subscription returns immediately, manually decrement expected request count for the remaining request handling
3324 xappConn1.DecrementRequestCount()
3326 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3328 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3329 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3330 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3331 assert.NotEqual(t, e2SubsId2, 0)
3333 mainCtrl.WaitOngoingRequestMapEmpty()
3335 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3336 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3337 xappConn1.ExpectAnyNotification(t)
3338 // Resend the original request again with only one e2 subscription (detail), WITHOUT restsubsid
3339 // md5sum shall find the original request
3340 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3341 assert.Equal(t, restSubId_resend, restSubId_resend2)
3343 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3344 assert.Equal(t, e2SubsId, e2SubsId1)
3346 mainCtrl.WaitOngoingRequestMapEmpty()
3348 // Delete both e2 subscriptions
3349 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3350 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3351 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3353 waitSubsCleanup(t, e2SubsId, 10)
3354 mainCtrl.VerifyCounterValues(t)
3355 mainCtrl.VerifyAllClean(t)
3358 //-----------------------------------------------------------------------------
3360 // +-------+ +---------+ +---------+ +---------+
3361 // | xapp | | submgr | | e2term | | rtmgr |
3362 // +-------+ +---------+ +---------+ +---------+
3364 // | RESTSubReq | | |
3365 // |---------------->| | |
3366 // | RESTSubResp | | |
3367 // |<----------------| | |
3368 // | | RouteCreate | |
3369 // | |--------------------------->|
3370 // | | RouteResponse| |
3371 // | |<---------------------------|
3373 // | |------------->| |
3375 // | |<-------------| |
3376 // | RESTNotif1 | | |
3377 // |<----------------| | |
3378 // | RESTSubReq | | |
3379 // | [with RestSUbsId + one additional e2 subDetail]
3380 // |---------------->| | |
3381 // | RESTNotif1 | | |
3382 // | [for initial e2 subDetail] | |
3383 // |<----------------| | |
3384 // | | RouteCreate | |
3385 // | |--------------------------->|
3386 // | | RouteResponse| |
3387 // | |<---------------------------|
3389 // | |------------->| |
3391 // | |<-------------| |
3392 // | RESTNotif1 | | |
3393 // |<----------------| | |
3394 // | RESTSubDelReq | | |
3395 // |---------------->| | |
3396 // | RESTSubDelResp| | |
3397 // |<----------------| | |
3398 // | | SubDelReq | |
3399 // | |------------->| |
3400 // | | SubDelResp | |
3401 // | |<-------------| |
3402 // | | SubDelReq | |
3403 // | |------------->| |
3404 // | | SubDelResp | |
3405 // | |<-------------| |
3406 // | RESTSubReq | | |
3407 // | [with RESTsubsId initial request] |
3408 // |---------------->| | |
3409 // | RESTSubResp | | |
3410 // |<----------------| | |
3411 // | | RouteCreate | |
3412 // | |--------------------------->|
3413 // | | RouteResponse| |
3414 // | |<---------------------------|
3416 // | |------------->| |
3418 // | |<-------------| |
3419 // | RESTNotif1 | | |
3420 // |<----------------| | |
3423 //-----------------------------------------------------------------------------
3424 func TestRESTSubReqRetransmissionV6(t *testing.T) {
3425 CaseBegin("TestRESTSubReqRetransmissionV6")
3427 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3428 Counter{cRestSubReqFromXapp, 3},
3429 Counter{cDuplicateE2SubReq, 1},
3430 Counter{cRestSubRespToXapp, 3},
3431 Counter{cSubReqToE2, 3},
3432 Counter{cSubRespFromE2, 3},
3433 Counter{cRestSubNotifToXapp, 4},
3434 Counter{cRestSubDelReqFromXapp, 2},
3435 Counter{cSubDelReqToE2, 3},
3436 Counter{cSubDelRespFromE2, 3},
3437 Counter{cRestSubDelRespToXapp, 2},
3440 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3442 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3444 mainCtrl.WaitOngoingRequestMapEmpty()
3446 // Send modified requst, this time with e2 subscriptions.
3447 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3448 params2.SetSubscriptionID(&restSubId)
3450 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3451 xappConn1.ExpectAnyNotification(t)
3452 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3453 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3455 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3456 assert.Equal(t, e2SubsId, e2SubsId1)
3458 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3460 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3461 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3462 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3463 assert.NotEqual(t, e2SubsId2, 0)
3465 mainCtrl.WaitOngoingRequestMapEmpty()
3467 // Delete both e2 subscriptions
3468 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3469 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3470 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3472 waitSubsCleanup(t, e2SubsId, 10)
3474 // Resend the original request, we shall find it's previous md5sum/restsubs
3475 // but the restsubscription has been already removed. This shall trigger a
3477 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
3479 mainCtrl.WaitOngoingRequestMapEmpty()
3481 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3483 waitSubsCleanup(t, e2SubsId, 10)
3484 mainCtrl.VerifyCounterValues(t)
3485 mainCtrl.VerifyAllClean(t)
3488 func TestRESTSubDelReqRetransmission(t *testing.T) {
3489 CaseBegin("TestRESTSubDelReqRetransmission")
3491 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3492 Counter{cRestSubReqFromXapp, 1},
3493 Counter{cRestSubRespToXapp, 1},
3494 Counter{cSubReqToE2, 1},
3495 Counter{cSubRespFromE2, 1},
3496 Counter{cRestSubNotifToXapp, 1},
3497 Counter{cRestSubDelReqFromXapp, 2},
3498 Counter{cSubDelReqToE2, 1},
3499 Counter{cSubDelRespFromE2, 1},
3500 Counter{cRestSubDelRespToXapp, 2},
3503 var params *teststube2ap.RESTSubsReqParams = nil
3506 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3508 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3511 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3512 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3514 seqBef := mainCtrl.get_msgcounter(t)
3515 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3516 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
3518 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3520 waitSubsCleanup(t, e2SubsId, 10)
3521 mainCtrl.VerifyCounterValues(t)
3522 mainCtrl.VerifyAllClean(t)
3525 //-----------------------------------------------------------------------------
3526 // TestRESTSubReqDelReq
3529 // +-------+ +---------+ +---------+
3530 // | xapp | | submgr | | e2term |
3531 // +-------+ +---------+ +---------+
3534 // |---------------->| |
3536 // | RESTSubResp | |
3537 // |<----------------| |
3539 // | |------------->|
3540 // | RESTSubDelReq | |
3541 // |---------------->| |
3542 // | RESTSubDelResp | |
3544 // |<----------------| |
3546 // | |<-------------|
3548 // |<----------------| |
3550 // | [SUBS DELETE] |
3553 //-----------------------------------------------------------------------------
3554 func TestRESTSubReqDelReq(t *testing.T) {
3555 CaseBegin("TestRESTSubReqDelReq")
3557 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3558 Counter{cRestSubReqFromXapp, 1},
3559 Counter{cRestSubRespToXapp, 1},
3560 Counter{cSubReqToE2, 1},
3561 Counter{cSubRespFromE2, 1},
3562 Counter{cRestSubNotifToXapp, 1},
3563 Counter{cRestSubDelReqFromXapp, 2},
3564 Counter{cRestSubDelFailToXapp, 1},
3565 Counter{cSubDelReqToE2, 1},
3566 Counter{cSubDelRespFromE2, 1},
3567 Counter{cRestSubDelRespToXapp, 1},
3570 const subReqCount int = 1
3573 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3574 restSubId := xappConn1.SendRESTSubsReq(t, params)
3576 // Del. This will fail as processing of the subscription
3577 // is still ongoing in submgr. Deletion is not allowed before
3578 // subscription creation has been completed.
3579 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3580 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3581 xappConn1.ExpectRESTNotification(t, restSubId)
3582 e2termConn1.SendSubsResp(t, crereq, cremsg)
3583 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3586 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3588 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3589 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3591 // Wait that subs is cleaned
3592 waitSubsCleanup(t, e2SubsId, 10)
3593 mainCtrl.VerifyCounterValues(t)
3594 mainCtrl.VerifyAllClean(t)
3597 func TestRESTSubDelReqCollision(t *testing.T) {
3598 CaseBegin("TestRESTSubDelReqCollision - not relevant for REST API")
3601 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
3602 CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel")
3604 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3605 Counter{cRestSubReqFromXapp, 2},
3606 Counter{cRestSubRespToXapp, 2},
3607 Counter{cSubReqToE2, 2},
3608 Counter{cSubRespFromE2, 2},
3609 Counter{cRestSubNotifToXapp, 2},
3610 Counter{cRestSubDelReqFromXapp, 2},
3611 Counter{cSubDelReqToE2, 2},
3612 Counter{cSubDelRespFromE2, 2},
3613 Counter{cRestSubDelRespToXapp, 2},
3617 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3618 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3619 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3622 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3623 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3624 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3626 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3627 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3629 //XappConn1 receives both of the responses
3630 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3633 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3635 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3637 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3638 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3639 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3640 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3643 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3645 deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
3647 //Wait that subs is cleaned
3648 mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
3649 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
3651 mainCtrl.VerifyCounterValues(t)
3652 mainCtrl.VerifyAllClean(t)
3655 func TestRESTSameSubsDiffRan(t *testing.T) {
3656 CaseBegin("TestRESTSameSubsDiffRan")
3658 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3659 Counter{cRestSubReqFromXapp, 2},
3660 Counter{cRestSubRespToXapp, 2},
3661 Counter{cSubReqToE2, 2},
3662 Counter{cSubRespFromE2, 2},
3663 Counter{cRestSubNotifToXapp, 2},
3664 Counter{cRestSubDelReqFromXapp, 2},
3665 Counter{cSubDelReqToE2, 2},
3666 Counter{cSubDelRespFromE2, 2},
3667 Counter{cRestSubDelRespToXapp, 2},
3670 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3671 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3672 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3674 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3675 params.SetMeid("RAN_NAME_2")
3676 restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
3677 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3680 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3682 deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
3684 //Wait that subs is cleaned
3685 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3686 waitSubsCleanup(t, e2SubsId2, 10)
3688 mainCtrl.VerifyCounterValues(t)
3689 mainCtrl.VerifyAllClean(t)
3692 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
3693 CaseBegin("TestRESTSubReqRetryInSubmgr start")
3695 // Init counter check
3696 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3697 Counter{cRestSubReqFromXapp, 1},
3698 Counter{cRestSubRespToXapp, 1},
3699 Counter{cSubReqToE2, 1},
3700 Counter{cSubReqTimerExpiry, 1},
3701 Counter{cSubReReqToE2, 1},
3702 Counter{cSubRespFromE2, 1},
3703 Counter{cRestSubNotifToXapp, 1},
3704 Counter{cRestSubDelReqFromXapp, 1},
3705 Counter{cSubDelReqToE2, 1},
3706 Counter{cSubDelRespFromE2, 1},
3707 Counter{cRestSubDelRespToXapp, 1},
3710 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3711 restSubId := xappConn1.SendRESTSubsReq(t, params)
3713 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3715 // Catch the first message and ignore it
3716 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3717 xapp.Logger.Debug("Ignore REST subscriber request for subscriber : %v", restSubId)
3719 // The second request is being handled normally
3720 crereq, cremsg = e2termConn1.RecvSubsReq(t)
3721 xappConn1.ExpectRESTNotification(t, restSubId)
3722 e2termConn1.SendSubsResp(t, crereq, cremsg)
3723 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3725 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3727 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3729 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
3730 //Wait that subs is cleaned
3731 waitSubsCleanup(t, e2SubsId, 10)
3733 mainCtrl.VerifyCounterValues(t)
3734 mainCtrl.VerifyAllClean(t)
3737 //-----------------------------------------------------------------------------
3738 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3741 // +-------+ +---------+ +---------+
3742 // | xapp | | submgr | | e2term |
3743 // +-------+ +---------+ +---------+
3746 // |---------------->| |
3748 // | RESTSubResp | |
3749 // |<----------------| |
3751 // | |------------->|
3755 // | |------------->|
3758 // | |------------->|
3762 // | |------------->|
3766 // | |<-------------|
3769 // |<----------------| |
3771 // | [SUBS DELETE] |
3774 //-----------------------------------------------------------------------------
3776 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
3777 CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
3779 // Init counter check
3780 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3781 Counter{cRestSubReqFromXapp, 1},
3782 Counter{cRestSubRespToXapp, 1},
3783 Counter{cSubReqToE2, 1},
3784 Counter{cSubReReqToE2, 1},
3785 Counter{cSubReqTimerExpiry, 2},
3786 Counter{cRestSubFailNotifToXapp, 1},
3787 Counter{cSubDelReqToE2, 1},
3788 Counter{cSubDelRespFromE2, 1},
3789 Counter{cRestSubDelReqFromXapp, 1},
3790 Counter{cRestSubDelRespToXapp, 1},
3793 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3794 restSubId := xappConn1.SendRESTSubsReq(t, params)
3795 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3797 e2termConn1.RecvSubsReq(t)
3798 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3800 e2termConn1.RecvSubsReq(t)
3801 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3803 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3804 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3805 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3806 xappConn1.WaitRESTNotification(t, restSubId)
3808 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3810 // Wait that subs is cleaned
3811 waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
3812 mainCtrl.VerifyCounterValues(t)
3813 mainCtrl.VerifyAllClean(t)
3816 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
3817 CaseBegin("TestREST2eTermNotRespondingToSubReq start")
3819 // Init counter check
3820 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3821 Counter{cRestSubReqFromXapp, 1},
3822 Counter{cRestSubRespToXapp, 1},
3823 Counter{cSubReqToE2, 1},
3824 Counter{cSubReReqToE2, 1},
3825 Counter{cSubReqTimerExpiry, 2},
3826 Counter{cSubDelReReqToE2, 1},
3827 Counter{cRestSubFailNotifToXapp, 1},
3828 Counter{cSubDelReqToE2, 1},
3829 Counter{cSubDelReqTimerExpiry, 2},
3830 Counter{cRestSubDelReqFromXapp, 1},
3831 Counter{cRestSubDelRespToXapp, 1},
3834 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3835 restSubId := xappConn1.SendRESTSubsReq(t, params)
3836 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3838 e2termConn1.RecvSubsReq(t)
3839 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3841 e2termConn1.RecvSubsReq(t)
3842 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3844 e2termConn1.RecvSubsDelReq(t)
3845 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3847 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3848 e2termConn1.RecvSubsDelReq(t)
3849 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3851 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3853 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3855 waitSubsCleanup(t, e2SubsId, 10)
3856 mainCtrl.VerifyCounterValues(t)
3857 mainCtrl.VerifyAllClean(t)
3860 //-----------------------------------------------------------------------------
3861 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3864 // +-------+ +---------+ +---------+
3865 // | xapp | | submgr | | e2term |
3866 // +-------+ +---------+ +---------+
3869 // |---------------->| |
3871 // | RESTSubResp | |
3872 // |<----------------| |
3874 // | |------------->|
3878 // | |------------->|
3881 // | |------------->|
3885 // | |------------->|
3889 // | |<-------------|
3892 // |<----------------| |
3894 // | [SUBS DELETE] |
3897 //-----------------------------------------------------------------------------
3898 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
3899 CaseBegin("TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr start")
3901 // Init counter check
3902 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3903 Counter{cRestSubReqFromXapp, 1},
3904 Counter{cRestSubRespToXapp, 1},
3905 Counter{cSubReqToE2, 1},
3906 Counter{cSubReReqToE2, 1},
3907 Counter{cSubReqTimerExpiry, 2},
3908 Counter{cRestSubFailNotifToXapp, 1},
3909 Counter{cSubDelReqToE2, 1},
3910 Counter{cSubDelReReqToE2, 1},
3911 Counter{cSubDelReqTimerExpiry, 2},
3912 Counter{cRestSubDelReqFromXapp, 1},
3913 Counter{cRestSubDelRespToXapp, 1},
3916 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3917 restSubId := xappConn1.SendRESTSubsReq(t, params)
3918 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3920 e2termConn1.RecvSubsReq(t)
3921 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3923 e2termConn1.RecvSubsReq(t)
3924 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3926 e2termConn1.RecvSubsDelReq(t)
3927 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3929 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3930 e2termConn1.RecvSubsDelReq(t)
3931 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3933 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3935 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3937 waitSubsCleanup(t, e2SubsId, 10)
3938 mainCtrl.VerifyCounterValues(t)
3939 mainCtrl.VerifyAllClean(t)
3942 //-----------------------------------------------------------------------------
3943 // TestRESTSubReqSubFailRespInSubmgr
3946 // +-------+ +---------+ +---------+
3947 // | xapp | | submgr | | e2term |
3948 // +-------+ +---------+ +---------+
3951 // |---------------->| |
3953 // | RESTSubResp | |
3954 // |<----------------| |
3956 // | |------------->|
3959 // | |<-------------|
3963 // |<----------------| |
3965 // | [SUBS DELETE] |
3968 //-----------------------------------------------------------------------------
3969 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
3970 CaseBegin("TestRESTSubReqSubFailRespInSubmgr")
3972 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3973 Counter{cRestSubReqFromXapp, 1},
3974 Counter{cRestSubRespToXapp, 1},
3975 Counter{cSubReqToE2, 1},
3976 Counter{cSubFailFromE2, 1},
3977 Counter{cRestSubFailNotifToXapp, 1},
3978 Counter{cRestSubDelReqFromXapp, 1},
3979 Counter{cRestSubDelRespToXapp, 1},
3982 const subReqCount int = 1
3983 const e2Timeout int64 = 2
3984 const e2RetryCount int64 = 1
3985 const routingNeeded bool = true
3987 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3988 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
3989 restSubId := xappConn1.SendRESTSubsReq(t, params)
3991 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3992 fparams1 := &teststube2ap.E2StubSubsFailParams{}
3993 fparams1.Set(crereq1)
3994 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3995 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3997 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3998 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
4000 // REST subscription sill there to be deleted
4001 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4003 // Wait that subs is cleaned
4004 waitSubsCleanup(t, e2SubsId, 10)
4006 mainCtrl.VerifyCounterValues(t)
4007 mainCtrl.VerifyAllClean(t)
4010 //-----------------------------------------------------------------------------
4011 // TestRESTSubDelReqRetryInSubmgr
4014 // +-------+ +---------+ +---------+
4015 // | xapp | | submgr | | e2term |
4016 // +-------+ +---------+ +---------+
4018 // | [SUBS CREATE] |
4021 // | RESTSubDelReq | |
4022 // |---------------->| |
4024 // | RESTSubDelResp | |
4025 // |<----------------| |
4027 // | |------------->|
4030 // | |------------->|
4033 // | |<-------------|
4036 //-----------------------------------------------------------------------------
4037 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
4038 CaseBegin("TestRESTSubDelReqRetryInSubmgr")
4040 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4041 Counter{cRestSubReqFromXapp, 1},
4042 Counter{cRestSubRespToXapp, 1},
4043 Counter{cSubReqToE2, 1},
4044 Counter{cSubRespFromE2, 1},
4045 Counter{cRestSubNotifToXapp, 1},
4046 Counter{cRestSubDelReqFromXapp, 1},
4047 Counter{cSubDelReqToE2, 1},
4048 Counter{cSubDelReqTimerExpiry, 1},
4049 Counter{cSubDelReReqToE2, 1},
4050 Counter{cSubDelRespFromE2, 1},
4051 Counter{cRestSubDelRespToXapp, 1},
4054 var params *teststube2ap.RESTSubsReqParams = nil
4055 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4058 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4060 // E2t: Receive 1st SubsDelReq
4061 e2termConn1.RecvSubsDelReq(t)
4063 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4064 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4065 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4067 //Wait that subs is cleaned
4068 waitSubsCleanup(t, e2SubsId, 10)
4070 mainCtrl.VerifyCounterValues(t)
4071 mainCtrl.VerifyAllClean(t)
4074 //-----------------------------------------------------------------------------
4075 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
4078 // +-------+ +---------+ +---------+
4079 // | xapp | | submgr | | e2term |
4080 // +-------+ +---------+ +---------+
4082 // | [SUBS CREATE] |
4085 // | RESTSubDelReq | |
4086 // |---------------->| |
4088 // | RESTSubDelResp | |
4089 // |<----------------| |
4091 // | |------------->|
4094 // | |------------->|
4098 //-----------------------------------------------------------------------------
4099 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
4100 CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr")
4102 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4103 Counter{cRestSubReqFromXapp, 1},
4104 Counter{cRestSubRespToXapp, 1},
4105 Counter{cSubReqToE2, 1},
4106 Counter{cSubRespFromE2, 1},
4107 Counter{cRestSubNotifToXapp, 1},
4108 Counter{cRestSubDelReqFromXapp, 1},
4109 Counter{cSubDelReqToE2, 1},
4110 Counter{cSubDelReqTimerExpiry, 1},
4111 Counter{cSubDelReReqToE2, 1},
4112 Counter{cSubDelRespFromE2, 1},
4113 Counter{cRestSubDelRespToXapp, 1},
4117 var params *teststube2ap.RESTSubsReqParams = nil
4118 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4121 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4123 // E2t: Receive 1st SubsDelReq
4124 e2termConn1.RecvSubsDelReq(t)
4126 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4127 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4128 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4130 //Wait that subs is cleaned
4131 waitSubsCleanup(t, e2SubsId, 10)
4133 mainCtrl.VerifyCounterValues(t)
4134 mainCtrl.VerifyAllClean(t)
4137 //-----------------------------------------------------------------------------
4138 // TestRESTSubDelReqSubDelFailRespInSubmgr
4141 // +-------+ +---------+ +---------+
4142 // | xapp | | submgr | | e2term |
4143 // +-------+ +---------+ +---------+
4145 // | [SUBS CREATE] |
4148 // | RESTSubDelReq | |
4149 // |---------------->| |
4151 // | RESTSubDelResp | |
4152 // |<----------------| |
4154 // | |------------->|
4157 // | |<-------------|
4160 //-----------------------------------------------------------------------------
4161 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
4162 CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr")
4164 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4165 Counter{cRestSubReqFromXapp, 1},
4166 Counter{cRestSubRespToXapp, 1},
4167 Counter{cSubReqToE2, 1},
4168 Counter{cSubRespFromE2, 1},
4169 Counter{cRestSubNotifToXapp, 1},
4170 Counter{cRestSubDelReqFromXapp, 1},
4171 Counter{cSubDelReqToE2, 1},
4172 Counter{cSubDelFailFromE2, 1},
4173 Counter{cRestSubDelRespToXapp, 1},
4177 var params *teststube2ap.RESTSubsReqParams = nil
4178 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4181 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4183 // E2t: Send receive SubsDelReq and send SubsDelFail
4184 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4185 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
4187 //Wait that subs is cleaned
4188 waitSubsCleanup(t, e2SubsId, 10)
4190 mainCtrl.VerifyCounterValues(t)
4191 mainCtrl.VerifyAllClean(t)
4194 //-----------------------------------------------------------------------------
4195 // TestRESTSubReqAndSubDelOkSameAction
4198 // +-------+ +-------+ +---------+ +---------+
4199 // | xapp2 | | xapp1 | | submgr | | e2term |
4200 // +-------+ +-------+ +---------+ +---------+
4202 // | | RESTSubReq1 | |
4203 // | |---------------->| |
4205 // | | RESTSubResp1 | |
4206 // | |<----------------| |
4209 // | | |------------->|
4211 // | | |<-------------|
4212 // | | RESTNotif1 | |
4213 // | |<----------------| |
4215 // | RESTSubReq2 | |
4216 // |------------------------------>| |
4218 // | RESTSubResp2 | |
4219 // |<------------------------------| |
4221 // | | RESTNotif2 | |
4222 // |<------------------------------| |
4224 // | | RESTSubDelReq1 | |
4225 // | |---------------->| |
4227 // | | RESTSubDelResp1 | |
4228 // | |<----------------| |
4230 // | RESTSubDelReq2 | |
4231 // |------------------------------>| |
4233 // | RESTSubDelResp2 | |
4234 // |<------------------------------| |
4236 // | | | SubDelReq2 |
4237 // | | |------------->|
4239 // | | | SubDelResp2 |
4240 // | | |<-------------|
4243 //-----------------------------------------------------------------------------
4244 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
4245 CaseBegin("TestRESTSubReqAndSubDelOkSameAction")
4247 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4248 Counter{cRestSubReqFromXapp, 2},
4249 Counter{cRestSubRespToXapp, 2},
4250 Counter{cSubReqToE2, 1},
4251 Counter{cSubRespFromE2, 1},
4252 Counter{cRestSubNotifToXapp, 2},
4253 Counter{cMergedSubscriptions, 1},
4254 Counter{cUnmergedSubscriptions, 1},
4255 Counter{cRestSubDelReqFromXapp, 2},
4256 Counter{cSubDelReqToE2, 1},
4257 Counter{cSubDelRespFromE2, 1},
4258 Counter{cRestSubDelRespToXapp, 2},
4262 var params *teststube2ap.RESTSubsReqParams = nil
4265 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4266 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4269 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4270 params.SetMeid("RAN_NAME_1")
4272 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4273 xappConn2.ExpectAnyNotification(t)
4274 waiter := rtmgrHttp.AllocNextSleep(10, true)
4275 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4276 waiter.WaitResult(t)
4277 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
4278 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
4279 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
4281 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
4284 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4287 deleteXapp2Subscription(t, &restSubId2)
4289 //Wait that subs is cleaned
4290 waitSubsCleanup(t, e2SubsId2, 10)
4291 mainCtrl.VerifyCounterValues(t)
4292 mainCtrl.VerifyAllClean(t)
4295 //-----------------------------------------------------------------------------
4296 // TestSubReqAndSubDelOkSameActionParallel
4299 // +-------+ +-------+ +---------+ +---------+
4300 // | xapp2 | | xapp1 | | submgr | | e2term |
4301 // +-------+ +-------+ +---------+ +---------+
4306 // | |------------->| |
4309 // | | |------------->|
4311 // |--------------------------->| |
4313 // | | |<-------------|
4315 // | |<-------------| |
4317 // | | |------------->|
4320 // | | |<-------------|
4322 // |<---------------------------| |
4324 // | | SubDelReq 1 | |
4325 // | |------------->| |
4327 // | | SubDelResp 1 | |
4328 // | |<-------------| |
4330 // | SubDelReq 2 | |
4331 // |--------------------------->| |
4333 // | | | SubDelReq 2 |
4334 // | | |------------->|
4336 // | | | SubDelReq 2 |
4337 // | | |------------->|
4339 // | SubDelResp 2 | |
4340 // |<---------------------------| |
4342 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
4343 CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel")
4345 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4346 Counter{cRestSubReqFromXapp, 2},
4347 Counter{cRestSubRespToXapp, 2},
4348 Counter{cSubReqToE2, 2},
4349 Counter{cSubRespFromE2, 2},
4350 Counter{cRestSubNotifToXapp, 2},
4351 Counter{cRestSubDelReqFromXapp, 2},
4352 Counter{cSubDelReqToE2, 2},
4353 Counter{cSubDelRespFromE2, 2},
4354 Counter{cRestSubDelRespToXapp, 2},
4357 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4358 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4359 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4361 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4362 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4364 xappConn1.ExpectRESTNotification(t, restSubId1)
4365 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4366 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4368 xappConn2.ExpectRESTNotification(t, restSubId2)
4369 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
4370 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
4371 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4374 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4375 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4376 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4377 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4380 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4381 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
4382 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
4384 waitSubsCleanup(t, e2SubsId2, 10)
4385 mainCtrl.VerifyCounterValues(t)
4386 mainCtrl.VerifyAllClean(t)
4389 //-----------------------------------------------------------------------------
4390 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
4393 // +-------+ +-------+ +---------+ +---------+
4394 // | xapp2 | | xapp1 | | submgr | | e2term |
4395 // +-------+ +-------+ +---------+ +---------+
4399 // | | RESTSubReq1 | |
4400 // | |---------------->| |
4402 // | | RESTSubResp1 | |
4403 // | |<----------------| |
4405 // | | |------------->|
4406 // | RESTSubReq2 | |
4407 // |------------------------------>| |
4409 // | RESTSubResp2 | |
4410 // |<------------------------------| |
4412 // | | |------------->|
4415 // | | | SubDelReq |
4416 // | | |------------->|
4418 // | | | SubDelResp |
4419 // | | |<-------------|
4420 // | | RESTNotif1 | |
4421 // | | unsuccess | |
4422 // | |<----------------| |
4424 // | | unsuccess | |
4425 // |<------------------------------| |
4427 // | | RESTSubDelReq1 | |
4428 // | |---------------->| |
4430 // | | RESTSubDelResp1 | |
4431 // | |<----------------| |
4433 // | RESTSubDelReq2 | |
4434 // |------------------------------>| |
4436 // | RESTSubDelResp2 | |
4437 // |<------------------------------| |
4439 //-----------------------------------------------------------------------------
4440 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
4441 CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
4443 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4444 Counter{cRestSubReqFromXapp, 2},
4445 Counter{cMergedSubscriptions, 1},
4446 Counter{cRestSubRespToXapp, 2},
4447 Counter{cSubReqToE2, 1},
4448 Counter{cSubReqTimerExpiry, 2},
4449 Counter{cSubReReqToE2, 1},
4450 Counter{cRestSubFailNotifToXapp, 2},
4451 Counter{cUnmergedSubscriptions, 1},
4452 Counter{cRestSubDelReqFromXapp, 2},
4453 Counter{cSubDelReqToE2, 1},
4454 Counter{cSubDelRespFromE2, 1},
4455 Counter{cRestSubDelRespToXapp, 2},
4457 const subReqCount int = 1
4460 params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4461 restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
4462 crereq1, _ := e2termConn1.RecvSubsReq(t)
4465 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4466 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4467 params2.SetMeid("RAN_NAME_1")
4468 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4469 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4471 //Req1 (retransmitted)
4472 e2termConn1.RecvSubsReq(t)
4474 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4476 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4477 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4479 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4480 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4481 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4482 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4485 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4488 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4490 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
4492 //Wait that subs is cleaned
4493 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4494 mainCtrl.VerifyCounterValues(t)
4495 mainCtrl.VerifyAllClean(t)
4498 //-----------------------------------------------------------------------------
4499 // TestRESTSubReqAndSubDelNokSameActionParallel
4502 // +-------+ +-------+ +---------+ +---------+
4503 // | xapp2 | | xapp1 | | submgr | | e2term |
4504 // +-------+ +-------+ +---------+ +---------+
4508 // | | RESTSubReq1 | |
4509 // | |---------------->| |
4511 // | | RESTSubResp1 | |
4512 // | |<----------------| |
4514 // | | |------------->|
4515 // | RESTSubReq2 | |
4516 // |------------------------------>| |
4518 // | RESTSubDelResp2 | |
4519 // |<------------------------------| |
4521 // | | |<-------------|
4523 // | | RESTNotif1 | |
4524 // | | unsuccess | |
4525 // | |<----------------| |
4527 // | | unsuccess | |
4528 // |<------------------------------| |
4530 // | | RESTSubDelReq1 | | There is no need for xApp to send delete for failed subscriptions but some xApp might do so.
4531 // | |---------------->| |
4533 // | | RESTSubDelResp1 | |
4534 // | |<----------------| |
4536 // | RESTSubDelReq2 | |
4537 // |------------------------------>| |
4539 // | RESTSubDelResp2 | |
4540 // |<------------------------------| |
4542 //-----------------------------------------------------------------------------
4543 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
4544 CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
4546 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4547 Counter{cRestSubReqFromXapp, 2},
4548 Counter{cMergedSubscriptions, 1},
4549 Counter{cRestSubRespToXapp, 2},
4550 Counter{cSubReqToE2, 1},
4551 Counter{cSubFailFromE2, 1},
4552 Counter{cRestSubFailNotifToXapp, 2},
4553 Counter{cUnmergedSubscriptions, 1},
4554 Counter{cRestSubDelReqFromXapp, 2},
4555 Counter{cRestSubDelRespToXapp, 2},
4558 const subReqCount int = 1
4561 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4562 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4563 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4566 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4567 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4568 params2.SetMeid("RAN_NAME_1")
4569 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4570 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4572 // E2t: send SubsFail (first)
4573 fparams1 := &teststube2ap.E2StubSubsFailParams{}
4574 fparams1.Set(crereq1)
4575 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
4577 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4578 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4579 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4580 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4581 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4584 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4587 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4589 //Wait that subs is cleaned
4590 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4591 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
4592 mainCtrl.VerifyCounterValues(t)
4593 mainCtrl.VerifyAllClean(t)
4596 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
4597 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4599 // Init counter check
4600 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4601 Counter{cRestSubReqFromXapp, 1},
4602 Counter{cRestSubRespToXapp, 1},
4603 Counter{cSubReqToE2, 1},
4604 Counter{cSubRespFromE2, 1},
4605 Counter{cRestSubNotifToXapp, 1},
4606 Counter{cRestSubDelReqFromXapp, 1},
4607 Counter{cSubDelReqToE2, 1},
4608 Counter{cSubDelRespFromE2, 1},
4609 Counter{cRestSubDelRespToXapp, 1},
4612 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4613 restSubId := xappConn1.SendRESTSubsReq(t, params)
4614 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
4616 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4617 xappConn1.ExpectRESTNotification(t, restSubId)
4618 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4619 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4620 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
4622 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4623 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4624 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4626 // Wait that subs is cleaned
4627 waitSubsCleanup(t, e2SubsId, 10)
4628 mainCtrl.VerifyCounterValues(t)
4629 mainCtrl.VerifyAllClean(t)
4632 //-----------------------------------------------------------------------------
4633 // TestRESTSubReqPolicyChangeAndSubDelOk
4636 // +-------+ +---------+ +---------+
4637 // | xapp | | submgr | | e2term |
4638 // +-------+ +---------+ +---------+
4641 // |---------------->| |
4643 // | RESTSubResp | |
4644 // |<----------------| |
4646 // | |------------->|
4649 // | |<-------------|
4652 // |<----------------| |
4655 // |---------------->| |
4657 // | RESTSubResp | |
4658 // |<----------------| |
4660 // | |------------->|
4663 // | |<-------------|
4666 // |<----------------| |
4668 // | RESTSubDelReq | |
4669 // |---------------->| |
4672 // | |------------->|
4675 // | |<-------------|
4677 // | RESTSubDelResp | |
4678 // |<----------------| |
4680 //-----------------------------------------------------------------------------
4681 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
4682 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4684 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4685 Counter{cRestSubReqFromXapp, 2},
4686 Counter{cRestSubRespToXapp, 2},
4687 Counter{cSubReqToE2, 2},
4688 Counter{cSubRespFromE2, 2},
4689 Counter{cRestSubNotifToXapp, 2},
4690 Counter{cRestSubDelReqFromXapp, 1},
4691 Counter{cSubDelReqToE2, 1},
4692 Counter{cSubDelRespFromE2, 1},
4693 Counter{cRestSubDelRespToXapp, 1},
4696 const subReqCount int = 1
4697 const e2Timeout int64 = 1
4698 const e2RetryCount int64 = 0
4699 const routingNeeded bool = true
4702 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4703 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4704 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4707 // GetRESTSubsReqPolicyParams sets some counters on tc side.
4709 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4710 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4711 params.SetSubscriptionID(&restSubId)
4712 params.SetTimeToWait("w200ms")
4713 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
4716 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4718 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4719 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4721 // Wait that subs is cleaned
4722 waitSubsCleanup(t, e2SubsId, 10)
4723 mainCtrl.VerifyCounterValues(t)
4724 mainCtrl.VerifyAllClean(t)
4727 //-----------------------------------------------------------------------------
4728 // TestRESTSubReqPolicyChangeNOk
4731 // +-------+ +---------+ +---------+
4732 // | xapp | | submgr | | e2term |
4733 // +-------+ +---------+ +---------+
4736 // |---------------->| |
4738 // | RESTSubResp | |
4739 // |<----------------| |
4741 // | |------------->|
4744 // | |<-------------|
4747 // |<----------------| |
4750 // |---------------->| |
4752 // | RESTSubUpdateFail(400 Bad request)
4754 // | RESTSubDelReq | |
4755 // |---------------->| |
4758 // | |------------->|
4761 // | |<-------------|
4763 // | RESTSubDelResp | |
4764 // |<----------------| |
4766 //-----------------------------------------------------------------------------
4767 func TestRESTSubReqPolicyChangeNOk(t *testing.T) {
4768 CaseBegin("TestRESTSubReqPolicyChangeNOk")
4770 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4771 Counter{cRestSubReqFromXapp, 2},
4772 Counter{cRestSubRespToXapp, 1},
4773 Counter{cSubReqToE2, 1},
4774 Counter{cSubRespFromE2, 1},
4775 Counter{cRestSubNotifToXapp, 1},
4776 Counter{cRestSubFailToXapp, 1},
4777 Counter{cRestSubDelReqFromXapp, 1},
4778 Counter{cSubDelReqToE2, 1},
4779 Counter{cSubDelRespFromE2, 1},
4780 Counter{cRestSubDelRespToXapp, 1},
4784 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4785 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4788 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4790 restSubIdUpd := strings.ToUpper(restSubId) // This makes RESTSubReq to fail
4791 params.SetSubscriptionID(&restSubIdUpd)
4792 params.SetTimeToWait("w200ms")
4794 restSubId2 := xappConn1.SendRESTSubsReq(t, params)
4795 assert.Equal(t, restSubId2, "")
4798 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4800 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4801 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4803 // Wait that subs is cleaned
4804 waitSubsCleanup(t, e2SubsId, 10)
4805 mainCtrl.VerifyCounterValues(t)
4806 mainCtrl.VerifyAllClean(t)
4809 //-----------------------------------------------------------------------------
4810 // TestRESTSubReqAndSubDelOkTwoE2termParallel
4813 // +-------+ +---------+ +---------+ +---------+
4814 // | xapp | | submgr | | e2term1 | | e2term2 |
4815 // +-------+ +---------+ +---------+ +---------+
4819 // | RESTSubReq1 | | |
4820 // |---------------->| | |
4822 // | RESTSubResp1 | | |
4823 // |<----------------| | |
4825 // | |------------->| |
4827 // | RESTSubReq2 | | |
4828 // |---------------->| | |
4830 // | RESTSubResp2 | | |
4831 // |<----------------| | |
4833 // | |---------------------------->|
4836 // | |<-------------| |
4837 // | RESTNotif1 | | |
4838 // |<----------------| | |
4840 // | |<----------------------------|
4841 // | RESTNotif2 | | |
4842 // |<----------------| | |
4844 // | [SUBS 1 DELETE] | |
4846 // | [SUBS 2 DELETE] | |
4849 //-----------------------------------------------------------------------------
4850 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
4851 CaseBegin("TestRESTSubReqAndSubDelOkTwoE2termParallel")
4853 // Init counter check
4854 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4855 Counter{cRestSubReqFromXapp, 2},
4856 Counter{cRestSubRespToXapp, 2},
4857 Counter{cSubReqToE2, 2},
4858 Counter{cSubRespFromE2, 2},
4859 Counter{cRestSubNotifToXapp, 2},
4860 Counter{cRestSubDelReqFromXapp, 2},
4861 Counter{cSubDelReqToE2, 2},
4862 Counter{cSubDelRespFromE2, 2},
4863 Counter{cRestSubDelRespToXapp, 2},
4866 const subReqCount int = 1
4869 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4870 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4871 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4874 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4875 params.SetMeid("RAN_NAME_11")
4876 // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
4877 // would not work as notification would not be received
4878 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4879 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
4882 xappConn1.ExpectRESTNotification(t, restSubId1)
4883 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4884 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4885 xapp.Logger.Debug("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
4888 xappConn2.ExpectRESTNotification(t, restSubId2)
4889 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
4890 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4891 xapp.Logger.Debug("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
4894 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4895 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4896 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4898 // Wait that subs is cleaned
4899 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4902 xappConn1.SendRESTSubsDelReq(t, &restSubId2)
4903 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
4904 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
4906 // Wait that subs is cleaned
4907 waitSubsCleanup(t, e2SubsId2, 10)
4909 mainCtrl.VerifyCounterValues(t)
4910 mainCtrl.VerifyAllClean(t)
4913 //-----------------------------------------------------------------------------
4914 // TestRESTSubReqAsn1EncodeFail
4916 // In this case submgr send RICSubscriptionDeleteRequest after encode failure which should not happen!
4918 // +-------+ +---------+ +---------+
4919 // | xapp | | submgr | | e2term |
4920 // +-------+ +---------+ +---------+
4923 // |---------------->| |
4925 // | RESTSubResp | |
4926 // |<----------------| |
4927 // | RESTSubDelReq | |
4928 // |---------------->| |
4929 // | RESTSubDelResp | |
4931 // |<----------------| |
4934 //-----------------------------------------------------------------------------
4935 func TestRESTSubReqAsn1EncodeFail(t *testing.T) {
4936 CaseBegin("TestRESTSubReqAsn1EncodeFail")
4938 xapp.Logger.Debug("Xapp-frame, v0.8.1 sufficient REST API validation")
4942 //-----------------------------------------------------------------------------
4943 // TestRESTSubReqInsertAndSubDelOk
4946 // +-------+ +---------+ +---------+
4947 // | xapp | | submgr | | e2term |
4948 // +-------+ +---------+ +---------+
4951 // |---------------->| |
4953 // | RESTSubResp | |
4954 // |<----------------| |
4957 // | |------------->|
4960 // | |<-------------|
4962 // |<----------------| |
4965 // | RESTSubDelReq | |
4966 // |---------------->| |
4969 // | |------------->|
4972 // | |<-------------|
4974 // | RESTSubDelResp| |
4975 // |<----------------| |
4977 //-----------------------------------------------------------------------------
4978 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
4979 CaseBegin("TestRESTInsertSubReqAndSubDelOk")
4981 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4982 Counter{cRestSubReqFromXapp, 1},
4983 Counter{cRestSubRespToXapp, 1},
4984 Counter{cSubReqToE2, 1},
4985 Counter{cSubRespFromE2, 1},
4986 Counter{cRestSubNotifToXapp, 1},
4987 Counter{cRestSubDelReqFromXapp, 1},
4988 Counter{cSubDelReqToE2, 1},
4989 Counter{cSubDelRespFromE2, 1},
4990 Counter{cRestSubDelRespToXapp, 1},
4993 const subReqCount int = 1
4995 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4996 params.SetSubActionTypes("insert")
4999 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5002 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5004 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5005 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5007 // Wait that subs is cleaned
5008 waitSubsCleanup(t, e2SubsId, 10)
5009 mainCtrl.VerifyCounterValues(t)
5010 mainCtrl.VerifyAllClean(t)
5013 //-----------------------------------------------------------------------------
5014 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
5017 // +-------+ +---------+ +---------+
5018 // | xapp | | submgr | | e2term |
5019 // +-------+ +---------+ +---------+
5022 // |------------->| |
5024 // | RESTSubResp | |
5025 // |<-------------| |
5027 // | |------------->|
5032 // | Submgr restart |
5036 // | |------------->|
5039 // | |<-------------|
5043 // |<-------------| |
5045 // | RESTSubDelReq| |
5046 // |------------->| |
5048 // |RESTSubDelResp| |
5049 // |<-------------| |
5051 //-----------------------------------------------------------------------------
5052 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
5053 CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle")
5055 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5056 Counter{cRestSubReqFromXapp, 1},
5057 Counter{cRestSubRespToXapp, 1},
5058 Counter{cSubReqToE2, 1},
5059 Counter{cSubDelReqFromXapp, 1},
5060 Counter{cSubDelReqToE2, 1},
5061 Counter{cSubDelRespFromE2, 1},
5062 Counter{cRestSubDelReqFromXapp, 1},
5063 Counter{cRestSubDelRespToXapp, 1},
5066 const subReqCount int = 1
5068 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5071 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
5072 restSubId := xappConn1.SendRESTSubsReq(t, params)
5073 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5075 e2termConn1.RecvSubsReq(t)
5077 mainCtrl.SetResetTestFlag(t, false)
5079 mainCtrl.SimulateRestart(t)
5080 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5082 // Deleletion of uncompleted subscription
5083 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5084 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5087 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5089 xappConn1.TestMsgChanEmpty(t)
5090 e2termConn1.TestMsgChanEmpty(t)
5091 mainCtrl.wait_registry_empty(t, 10)
5093 mainCtrl.VerifyCounterValues(t)
5094 mainCtrl.VerifyAllClean(t)
5097 //-----------------------------------------------------------------------------
5098 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
5101 // +-------+ +---------+ +---------+
5102 // | xapp | | submgr | | e2term |
5103 // +-------+ +---------+ +---------+
5106 // |---------------->| |
5108 // | RESTSubResp | |
5109 // |<----------------| |
5111 // | |------------->|
5114 // | |<-------------|
5117 // |<----------------| |
5120 // | Submgr restart |
5122 // | RESTSubDelReq | |
5123 // |---------------->| |
5126 // | |------------->|
5129 // | |<-------------|
5131 // | RESTSubDelResp | |
5132 // |<----------------| |
5134 //-----------------------------------------------------------------------------
5136 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
5137 CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle")
5139 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5140 Counter{cRestSubReqFromXapp, 1},
5141 Counter{cRestSubRespToXapp, 1},
5142 Counter{cSubReqToE2, 1},
5143 Counter{cSubRespFromE2, 1},
5144 Counter{cRestSubNotifToXapp, 1},
5145 Counter{cRestSubDelReqFromXapp, 1},
5146 Counter{cSubDelReqToE2, 1},
5147 Counter{cSubDelRespFromE2, 1},
5148 Counter{cRestSubDelRespToXapp, 1},
5151 // Create subscription
5152 var params *teststube2ap.RESTSubsReqParams = nil
5153 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5154 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5156 // Check subscription
5157 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5159 mainCtrl.SimulateRestart(t)
5160 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5162 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5163 // That needs to be completed before successful subscription query is possible
5164 <-time.After(time.Second * 1)
5166 // Check subscription
5167 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5169 // Delete subscription
5170 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
5172 //Wait that subs is cleaned
5173 waitSubsCleanup(t, e2SubsId, 10)
5175 mainCtrl.VerifyCounterValues(t)
5176 mainCtrl.VerifyAllClean(t)
5179 //-----------------------------------------------------------------------------
5180 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
5183 // +-------+ +-------+ +---------+ +---------+
5184 // | xapp2 | | xapp1 | | submgr | | e2term |
5185 // +-------+ +-------+ +---------+ +---------+
5187 // | | RESTSubReq1 | |
5188 // | |---------------->| |
5190 // | | RESTSubResp1 | |
5191 // | |<----------------| |
5194 // | | |------------->|
5196 // | | |<-------------|
5197 // | | RESTNotif1 | |
5198 // | |<----------------| |
5200 // | RESTSubReq2 | |
5201 // |------------------------------>| |
5203 // | RESTSubResp2 | |
5204 // |<------------------------------| |
5206 // | | RESTNotif2 | |
5207 // |<------------------------------| |
5209 // | | Submgr restart |
5211 // | | RESTSubDelReq1 | |
5212 // | |---------------->| |
5214 // | | RESTSubDelResp1 | |
5215 // | |<----------------| |
5217 // | | Submgr restart |
5219 // | RESTSubDelReq2 | |
5220 // |------------------------------>| |
5222 // | RESTSubDelResp2 | |
5223 // |<------------------------------| |
5225 // | | | SubDelReq2 |
5226 // | | |------------->|
5228 // | | | SubDelResp2 |
5229 // | | |<-------------|
5232 //-----------------------------------------------------------------------------
5233 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
5234 CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
5236 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5237 Counter{cRestSubReqFromXapp, 2},
5238 Counter{cRestSubRespToXapp, 2},
5239 Counter{cSubReqToE2, 1},
5240 Counter{cSubRespFromE2, 1},
5241 Counter{cRestSubNotifToXapp, 2},
5242 Counter{cMergedSubscriptions, 1},
5243 Counter{cUnmergedSubscriptions, 1},
5244 Counter{cRestSubDelReqFromXapp, 2},
5245 Counter{cSubDelReqToE2, 1},
5246 Counter{cSubDelRespFromE2, 1},
5247 Counter{cRestSubDelRespToXapp, 2},
5250 // Create subscription 1
5251 var params *teststube2ap.RESTSubsReqParams = nil
5252 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5253 xapp.Logger.Debug("Send REST subscriber request for subscriber 1 : %v", restSubId1)
5255 // Create subscription 2 with same action
5256 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5257 params.SetMeid("RAN_NAME_1")
5258 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
5259 xappConn2.ExpectAnyNotification(t)
5260 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5261 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5262 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
5263 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
5265 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
5267 mainCtrl.SimulateRestart(t)
5268 xapp.Logger.Debug("mainCtrl.SimulateRestart done 1")
5270 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5271 // That needs to be completed before successful subscription delete is possible
5272 <-time.After(time.Second * 1)
5274 // Delete subscription 1, and wait until it has removed the first endpoint
5275 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5276 mainCtrl.WaitRESTSubscriptionDelete(restSubId1)
5277 // Above wait does not work correctly anymore as this delay makes this test case work
5279 mainCtrl.SimulateRestart(t)
5280 xapp.Logger.Debug("mainCtrl.SimulateRestart done 2")
5282 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5283 // That needs to be completed before successful subscription query is possible
5284 <-time.After(time.Second * 1)
5286 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
5288 // Delete subscription 2
5289 deleteXapp2Subscription(t, &restSubId2)
5291 //Wait that subs is cleaned
5292 waitSubsCleanup(t, e2SubsId2, 10)
5294 mainCtrl.VerifyCounterValues(t)
5295 mainCtrl.VerifyAllClean(t)
5298 //-----------------------------------------------------------------------------
5299 // TestRESTReportSubReqAndSubDelOk
5302 // +-------+ +---------+ +---------+
5303 // | xapp | | submgr | | e2term |
5304 // +-------+ +---------+ +---------+
5307 // |---------------->| |
5309 // | RESTSubResp | |
5310 // |<----------------| |
5313 // | |------------->|
5316 // | |<-------------|
5318 // |<----------------| |
5320 // | |------------->|
5323 // | |<-------------|
5325 // |<----------------| |
5329 // | RESTSubDelReq | |
5330 // |---------------->| |
5333 // | |------------->|
5336 // | |<-------------|
5338 // | RESTSubDelResp| |
5339 // |<----------------| |
5341 //-----------------------------------------------------------------------------
5343 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
5344 CaseBegin("TestRESTReportSubReqAndSubDelOk")
5345 const subReqCount int = 1
5347 RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
5350 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5351 xapp.Logger.Debug("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
5354 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5355 restSubId := xappConn1.SendRESTSubsReq(t, params)
5357 var e2SubsId []uint32
5358 for i := 0; i < subReqCount; i++ {
5359 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5360 xappConn1.ExpectRESTNotification(t, restSubId)
5362 e2termConn1.SendSubsResp(t, crereq, cremsg)
5363 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5364 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5365 e2SubsId = append(e2SubsId, instanceId)
5366 resp, _ := xapp.Subscription.QuerySubscriptions()
5367 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
5368 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
5369 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
5374 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5376 for i := 0; i < subReqCount; i++ {
5377 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5378 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5381 // Wait that subs is cleaned
5382 for i := 0; i < subReqCount; i++ {
5383 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5386 xappConn1.TestMsgChanEmpty(t)
5387 e2termConn1.TestMsgChanEmpty(t)
5388 mainCtrl.wait_registry_empty(t, 10)
5389 mainCtrl.VerifyAllClean(t)
5393 func TestRESTPolicySubReqAndSubDelOk(t *testing.T) { was in comments already
5394 CaseBegin("TestRESTPolicySubReqAndSubDelOk")
5398 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5402 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5405 func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5406 xapp.Logger.Debug("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
5409 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5410 restSubId := xappConn1.SendRESTSubsReq(t, params)
5412 var e2SubsId []uint32
5413 for i := 0; i < subReqCount; i++ {
5414 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5415 xappConn1.ExpectRESTNotification(t, restSubId)
5416 e2termConn1.SendSubsResp(t, crereq, cremsg)
5417 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5418 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5419 e2SubsId = append(e2SubsId, instanceId)
5423 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5425 for i := 0; i < subReqCount; i++ {
5426 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5427 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5430 // Wait that subs is cleaned
5431 for i := 0; i < subReqCount; i++ {
5432 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5434 xappConn1.TestMsgChanEmpty(t)
5435 e2termConn1.TestMsgChanEmpty(t)
5436 mainCtrl.wait_registry_empty(t, 10)
5437 mainCtrl.VerifyAllClean(t)
5440 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
5442 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5443 Counter{cRestSubReqFromXapp, 1},
5444 Counter{cRestSubRespToXapp, 1},
5445 Counter{cSubReqToE2, 2},
5446 Counter{cSubRespFromE2, 2},
5447 Counter{cRestSubNotifToXapp, 2},
5448 Counter{cRestSubDelReqFromXapp, 1},
5449 Counter{cSubDelReqToE2, 2},
5450 Counter{cSubDelRespFromE2, 2},
5451 Counter{cRestSubDelRespToXapp, 1},
5454 const subReqCount int = 2
5457 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5458 restSubId := xappConn1.SendRESTSubsReq(t, params)
5459 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5461 assert.Equal(t, len(e2SubsIds), 2)
5464 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5465 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5467 xappConn1.TestMsgChanEmpty(t)
5468 e2termConn1.TestMsgChanEmpty(t)
5469 mainCtrl.wait_registry_empty(t, 10)
5471 mainCtrl.VerifyCounterValues(t)
5472 mainCtrl.VerifyAllClean(t)
5474 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
5476 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5477 Counter{cRestSubReqFromXapp, 1},
5478 Counter{cRestSubRespToXapp, 1},
5479 Counter{cSubReqToE2, 19},
5480 Counter{cSubRespFromE2, 19},
5481 Counter{cRestSubNotifToXapp, 19},
5482 Counter{cRestSubDelReqFromXapp, 1},
5483 Counter{cSubDelReqToE2, 19},
5484 Counter{cSubDelRespFromE2, 19},
5485 Counter{cRestSubDelRespToXapp, 1},
5488 const subReqCount int = 19
5490 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5491 restSubId := xappConn1.SendRESTSubsReq(t, params)
5492 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5494 assert.Equal(t, len(e2SubsIds), 19)
5496 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5497 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5499 xappConn1.TestMsgChanEmpty(t)
5500 e2termConn1.TestMsgChanEmpty(t)
5501 mainCtrl.wait_registry_empty(t, 10)
5503 mainCtrl.VerifyCounterValues(t)
5504 mainCtrl.VerifyAllClean(t)
5507 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
5511 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5512 Counter{cRestSubReqFromXapp, 1},
5513 Counter{cRestSubRespToXapp, 1},
5514 Counter{cSubReqToE2, uint64(subReqCount)},
5515 Counter{cSubRespFromE2, uint64(subReqCount)},
5516 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5517 Counter{cRestSubDelReqFromXapp, 1},
5518 Counter{cSubDelReqToE2, uint64(subReqCount)},
5519 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5520 Counter{cRestSubDelRespToXapp, 1},
5524 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5525 restSubId := xappConn1.SendRESTSubsReq(t, params)
5526 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5528 assert.Equal(t, len(e2SubsIds), subReqCount)
5531 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5532 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5534 xappConn1.TestMsgChanEmpty(t)
5535 e2termConn1.TestMsgChanEmpty(t)
5536 mainCtrl.wait_registry_empty(t, 10)
5538 mainCtrl.VerifyCounterValues(t)
5539 mainCtrl.VerifyAllClean(t)
5542 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
5546 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5547 Counter{cRestSubReqFromXapp, 1},
5548 Counter{cRestSubRespToXapp, 1},
5549 Counter{cSubReqToE2, uint64(subReqCount)},
5550 Counter{cSubRespFromE2, uint64(subReqCount)},
5551 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5552 Counter{cRestSubDelReqFromXapp, 1},
5553 Counter{cSubDelReqToE2, uint64(subReqCount)},
5554 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5555 Counter{cRestSubDelRespToXapp, 1},
5559 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5560 restSubId := xappConn1.SendRESTSubsReq(t, params)
5561 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5563 assert.Equal(t, len(e2SubsIds), subReqCount)
5566 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5567 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5569 xappConn1.TestMsgChanEmpty(t)
5570 e2termConn1.TestMsgChanEmpty(t)
5571 mainCtrl.wait_registry_empty(t, 10)
5573 mainCtrl.VerifyCounterValues(t)
5574 mainCtrl.VerifyAllClean(t)
5577 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
5581 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5582 Counter{cRestSubReqFromXapp, 1},
5583 Counter{cRestSubRespToXapp, 1},
5584 Counter{cSubReqToE2, uint64(subReqCount)},
5585 Counter{cSubRespFromE2, uint64(subReqCount)},
5586 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5587 Counter{cRestSubDelReqFromXapp, 1},
5588 Counter{cSubDelReqToE2, uint64(subReqCount)},
5589 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5590 Counter{cRestSubDelRespToXapp, 1},
5594 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5595 restSubId := xappConn1.SendRESTSubsReq(t, params)
5596 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5598 assert.Equal(t, len(e2SubsIds), subReqCount)
5601 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5602 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5604 xappConn1.TestMsgChanEmpty(t)
5605 e2termConn1.TestMsgChanEmpty(t)
5606 mainCtrl.wait_registry_empty(t, 10)
5608 mainCtrl.VerifyCounterValues(t)
5609 mainCtrl.VerifyAllClean(t)
5612 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
5613 CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
5615 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5616 Counter{cRestSubReqFromXapp, 2},
5617 Counter{cRestSubRespToXapp, 2},
5618 Counter{cSubReqToE2, 2},
5619 Counter{cSubRespFromE2, 2},
5620 Counter{cRestSubNotifToXapp, 2},
5621 Counter{cRestSubDelReqFromXapp, 2},
5622 Counter{cSubDelReqToE2, 2},
5623 Counter{cSubDelRespFromE2, 2},
5624 Counter{cRestSubDelRespToXapp, 2},
5628 var params *teststube2ap.RESTSubsReqParams = nil
5631 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5632 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5634 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5637 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5638 params.SetMeid("RAN_NAME_1")
5639 eventTriggerDefinition := []int64{1234, 1}
5640 params.SetSubEventTriggerDefinition(eventTriggerDefinition)
5642 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5643 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5644 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5645 xappConn2.ExpectRESTNotification(t, restSubId2)
5646 e2termConn1.SendSubsResp(t, crereq, cremsg)
5647 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5649 deleteXapp1Subscription(t, &restSubId1)
5650 deleteXapp2Subscription(t, &restSubId2)
5652 waitSubsCleanup(t, e2SubsId1, 10)
5653 waitSubsCleanup(t, e2SubsId2, 10)
5655 mainCtrl.VerifyCounterValues(t)
5656 mainCtrl.VerifyAllClean(t)
5659 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
5660 CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
5662 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5663 Counter{cRestSubReqFromXapp, 2},
5664 Counter{cRestSubRespToXapp, 2},
5665 Counter{cSubReqToE2, 2},
5666 Counter{cSubRespFromE2, 2},
5667 Counter{cRestSubNotifToXapp, 2},
5668 Counter{cRestSubDelReqFromXapp, 2},
5669 Counter{cSubDelReqToE2, 2},
5670 Counter{cSubDelRespFromE2, 2},
5671 Counter{cRestSubDelRespToXapp, 2},
5675 var params *teststube2ap.RESTSubsReqParams = nil
5678 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5679 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5681 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5684 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5685 params.SetMeid("RAN_NAME_1")
5687 actionId := int64(1)
5688 actionType := "report"
5689 actionDefinition := []int64{5678, 1}
5690 subsequestActionType := "continue"
5691 timeToWait := "w10ms"
5692 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
5694 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5695 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5696 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5697 xappConn2.ExpectRESTNotification(t, restSubId2)
5698 e2termConn1.SendSubsResp(t, crereq, cremsg)
5699 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5701 deleteXapp1Subscription(t, &restSubId1)
5702 deleteXapp2Subscription(t, &restSubId2)
5704 waitSubsCleanup(t, e2SubsId1, 10)
5705 waitSubsCleanup(t, e2SubsId2, 10)
5707 mainCtrl.VerifyCounterValues(t)
5708 mainCtrl.VerifyAllClean(t)
5711 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
5712 CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
5714 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5715 Counter{cRestSubReqFromXapp, 2},
5716 Counter{cRestSubRespToXapp, 2},
5717 Counter{cSubReqToE2, 2},
5718 Counter{cSubRespFromE2, 2},
5719 Counter{cRestSubNotifToXapp, 2},
5720 Counter{cRestSubDelReqFromXapp, 2},
5721 Counter{cSubDelReqToE2, 2},
5722 Counter{cSubDelRespFromE2, 2},
5723 Counter{cRestSubDelRespToXapp, 2},
5727 var params *teststube2ap.RESTSubsReqParams = nil
5730 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5731 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5733 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5736 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5737 params.SetMeid("RAN_NAME_1")
5738 params.SetSubActionIDs(int64(2))
5740 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5741 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5742 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5743 xappConn2.ExpectRESTNotification(t, restSubId2)
5744 e2termConn1.SendSubsResp(t, crereq, cremsg)
5745 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5747 deleteXapp1Subscription(t, &restSubId1)
5748 deleteXapp2Subscription(t, &restSubId2)
5750 waitSubsCleanup(t, e2SubsId1, 10)
5751 waitSubsCleanup(t, e2SubsId2, 10)
5753 mainCtrl.VerifyCounterValues(t)
5754 mainCtrl.VerifyAllClean(t)
5757 func TestRESTSubReqDiffActionType(t *testing.T) {
5758 CaseBegin("TestRESTSubReqDiffActionType")
5760 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5761 Counter{cRestSubReqFromXapp, 2},
5762 Counter{cRestSubRespToXapp, 2},
5763 Counter{cSubReqToE2, 2},
5764 Counter{cSubRespFromE2, 2},
5765 Counter{cRestSubNotifToXapp, 2},
5766 Counter{cRestSubDelReqFromXapp, 2},
5767 Counter{cSubDelReqToE2, 2},
5768 Counter{cSubDelRespFromE2, 2},
5769 Counter{cRestSubDelRespToXapp, 2},
5772 const e2Timeout int64 = 2
5773 const e2RetryCount int64 = 2
5774 const routingNeeded bool = true
5777 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5778 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5781 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5782 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5784 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5787 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5788 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5789 params.SetMeid("RAN_NAME_1")
5791 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5792 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5793 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5794 xappConn2.ExpectRESTNotification(t, restSubId2)
5795 e2termConn1.SendSubsResp(t, crereq, cremsg)
5796 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5798 deleteXapp1Subscription(t, &restSubId1)
5799 deleteXapp2Subscription(t, &restSubId2)
5801 waitSubsCleanup(t, e2SubsId1, 10)
5802 waitSubsCleanup(t, e2SubsId2, 10)
5804 mainCtrl.VerifyCounterValues(t)
5805 mainCtrl.VerifyAllClean(t)
5808 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
5809 CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
5811 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5812 Counter{cRestSubReqFromXapp, 2},
5813 Counter{cRestSubRespToXapp, 2},
5814 Counter{cSubReqToE2, 2},
5815 Counter{cSubRespFromE2, 2},
5816 Counter{cRestSubNotifToXapp, 2},
5817 Counter{cRestSubDelReqFromXapp, 2},
5818 Counter{cSubDelReqToE2, 2},
5819 Counter{cSubDelRespFromE2, 2},
5820 Counter{cRestSubDelRespToXapp, 2},
5823 const e2Timeout int64 = 2
5824 const e2RetryCount int64 = 2
5825 const routingNeeded bool = true
5828 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5829 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5832 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5833 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5835 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5838 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
5839 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5840 params.SetMeid("RAN_NAME_1")
5842 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5843 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5844 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5845 xappConn2.ExpectRESTNotification(t, restSubId2)
5846 e2termConn1.SendSubsResp(t, crereq, cremsg)
5847 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5849 deleteXapp1Subscription(t, &restSubId1)
5850 deleteXapp2Subscription(t, &restSubId2)
5852 waitSubsCleanup(t, e2SubsId1, 10)
5853 waitSubsCleanup(t, e2SubsId2, 10)
5855 mainCtrl.VerifyCounterValues(t)
5856 mainCtrl.VerifyAllClean(t)
5859 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
5860 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
5862 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5863 Counter{cRestSubReqFromXapp, 2},
5864 Counter{cRestSubRespToXapp, 2},
5865 Counter{cSubReqToE2, 2},
5866 Counter{cSubRespFromE2, 2},
5867 Counter{cRestSubNotifToXapp, 2},
5868 Counter{cRestSubDelReqFromXapp, 2},
5869 Counter{cSubDelReqToE2, 2},
5870 Counter{cSubDelRespFromE2, 2},
5871 Counter{cRestSubDelRespToXapp, 2},
5875 var params *teststube2ap.RESTSubsReqParams = nil
5878 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5879 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5881 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5884 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5885 params.SetMeid("RAN_NAME_1")
5886 actionDefinition := []int64{5678, 1}
5887 params.SetSubActionDefinition(actionDefinition)
5889 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5890 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5891 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5892 xappConn2.ExpectRESTNotification(t, restSubId2)
5893 e2termConn1.SendSubsResp(t, crereq, cremsg)
5894 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5896 deleteXapp1Subscription(t, &restSubId1)
5897 deleteXapp2Subscription(t, &restSubId2)
5899 waitSubsCleanup(t, e2SubsId1, 10)
5900 waitSubsCleanup(t, e2SubsId2, 10)
5902 mainCtrl.VerifyCounterValues(t)
5903 mainCtrl.VerifyAllClean(t)
5906 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
5907 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
5909 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5910 Counter{cRestSubReqFromXapp, 2},
5911 Counter{cRestSubRespToXapp, 2},
5912 Counter{cSubReqToE2, 2},
5913 Counter{cSubRespFromE2, 2},
5914 Counter{cRestSubNotifToXapp, 2},
5915 Counter{cRestSubDelReqFromXapp, 2},
5916 Counter{cSubDelReqToE2, 2},
5917 Counter{cSubDelRespFromE2, 2},
5918 Counter{cRestSubDelRespToXapp, 2},
5922 var params *teststube2ap.RESTSubsReqParams = nil
5925 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5926 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5928 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5931 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5932 params.SetMeid("RAN_NAME_1")
5933 actionDefinition := []int64{56782}
5934 params.SetSubActionDefinition(actionDefinition)
5936 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5937 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5938 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5939 xappConn2.ExpectRESTNotification(t, restSubId2)
5940 e2termConn1.SendSubsResp(t, crereq, cremsg)
5941 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5943 deleteXapp1Subscription(t, &restSubId1)
5944 deleteXapp2Subscription(t, &restSubId2)
5946 waitSubsCleanup(t, e2SubsId1, 10)
5947 waitSubsCleanup(t, e2SubsId2, 10)
5949 mainCtrl.VerifyCounterValues(t)
5950 mainCtrl.VerifyAllClean(t)
5953 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
5954 CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
5956 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5957 Counter{cRestSubReqFromXapp, 2},
5958 Counter{cRestSubRespToXapp, 2},
5959 Counter{cSubReqToE2, 2},
5960 Counter{cSubRespFromE2, 2},
5961 Counter{cRestSubNotifToXapp, 2},
5962 Counter{cRestSubDelReqFromXapp, 2},
5963 Counter{cSubDelReqToE2, 2},
5964 Counter{cSubDelRespFromE2, 2},
5965 Counter{cRestSubDelRespToXapp, 2},
5969 var params *teststube2ap.RESTSubsReqParams = nil
5972 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5973 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5975 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5978 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5979 params.SetMeid("RAN_NAME_1")
5980 params.SetTimeToWait("w200ms")
5981 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5982 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5983 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5984 xappConn2.ExpectRESTNotification(t, restSubId2)
5985 e2termConn1.SendSubsResp(t, crereq, cremsg)
5986 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5988 deleteXapp1Subscription(t, &restSubId1)
5989 deleteXapp2Subscription(t, &restSubId2)
5991 waitSubsCleanup(t, e2SubsId1, 10)
5992 waitSubsCleanup(t, e2SubsId2, 10)
5994 mainCtrl.VerifyCounterValues(t)
5995 mainCtrl.VerifyAllClean(t)
5998 //-----------------------------------------------------------------------------
5999 // TestRESTUnpackSubscriptionResponseDecodeFail
6002 // +-------+ +---------+ +---------+
6003 // | xapp | | submgr | | e2term |
6004 // +-------+ +---------+ +---------+
6007 // |---------------->| |
6009 // | RESTSubResp | |
6010 // |<----------------| |
6013 // | |------------->|
6015 // | | SubResp | ASN.1 decode fails
6016 // | |<-------------|
6019 // | |------------->|
6021 // | | SubFail | Duplicated action
6022 // | |<-------------|
6023 // | RESTNotif (fail)| |
6024 // |<----------------| |
6027 //-----------------------------------------------------------------------------
6029 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
6030 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
6031 const subReqCount int = 1
6034 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6035 restSubId := xappConn1.SendRESTSubsReq(t, params)
6037 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6038 // Decode of this response fails which will result resending original request
6039 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
6041 _, cremsg = e2termConn1.RecvSubsReq(t)
6043 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6045 // Subscription already created in E2 Node.
6046 fparams := &teststube2ap.E2StubSubsFailParams{}
6048 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6049 e2termConn1.SendSubsFail(t, fparams, cremsg)
6051 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6052 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6054 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6056 // Wait that subs is cleaned
6057 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6059 xappConn1.TestMsgChanEmpty(t)
6060 e2termConn1.TestMsgChanEmpty(t)
6061 mainCtrl.wait_registry_empty(t, 10)
6062 mainCtrl.VerifyAllClean(t)
6065 //-----------------------------------------------------------------------------
6066 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
6069 // +-------+ +---------+ +---------+
6070 // | xapp | | submgr | | e2term |
6071 // +-------+ +---------+ +---------+
6074 // |---------------->| |
6076 // | RESTSubResp | |
6077 // |<----------------| |
6080 // | |------------->|
6082 // | | SubResp | Unknown instanceId
6083 // | |<-------------|
6086 // | |------------->|
6088 // | | SubFail | Duplicated action
6089 // | |<-------------|
6090 // | RESTNotif (fail)| |
6091 // |<----------------| |
6093 // | |------------->|
6096 // | |<-------------|
6098 //-----------------------------------------------------------------------------
6100 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
6101 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
6102 const subReqCount int = 1
6105 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6106 restSubId := xappConn1.SendRESTSubsReq(t, params)
6108 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6110 // Unknown instanceId in this response which will result resending original request
6111 orgInstanceId := crereq.RequestId.InstanceId
6112 crereq.RequestId.InstanceId = 0
6113 e2termConn1.SendSubsResp(t, crereq, cremsg)
6115 _, cremsg = e2termConn1.RecvSubsReq(t)
6117 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6119 // Subscription already created in E2 Node.
6120 fparams := &teststube2ap.E2StubSubsFailParams{}
6122 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6123 e2termConn1.SendSubsFail(t, fparams, cremsg)
6125 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6126 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6128 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6129 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6131 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6133 // Wait that subs is cleaned
6134 mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
6136 xappConn1.TestMsgChanEmpty(t)
6137 e2termConn1.TestMsgChanEmpty(t)
6138 mainCtrl.wait_registry_empty(t, 10)
6139 mainCtrl.VerifyAllClean(t)
6142 //-----------------------------------------------------------------------------
6143 // TestRESTUnpackSubscriptionResponseNoTransaction
6146 // +-------+ +---------+ +---------+
6147 // | xapp | | submgr | | e2term |
6148 // +-------+ +---------+ +---------+
6151 // |---------------->| |
6153 // | RESTSubResp | |
6154 // |<----------------| |
6157 // | |------------->|
6159 // | | SubResp | No transaction for the response
6160 // | |<-------------|
6163 // | |------------->|
6165 // | | SubFail | Duplicated action
6166 // | |<-------------|
6167 // | RESTNotif (fail)| |
6168 // |<----------------| |
6170 // | |------------->|
6173 // | |<-------------|
6176 // | |------------->|
6179 // | |<-------------|
6181 //-----------------------------------------------------------------------------
6182 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
6183 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
6184 const subReqCount int = 1
6187 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6188 restSubId := xappConn1.SendRESTSubsReq(t, params)
6190 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6192 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6193 // No transaction exist for this response which will result resending original request
6194 e2termConn1.SendSubsResp(t, crereq, cremsg)
6196 _, cremsg = e2termConn1.RecvSubsReq(t)
6198 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6200 // Subscription already created in E2 Node.
6201 fparams := &teststube2ap.E2StubSubsFailParams{}
6203 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6204 e2termConn1.SendSubsFail(t, fparams, cremsg)
6206 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6207 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6209 // Resending happens because there no transaction
6210 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6211 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6213 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6214 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6216 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6218 // Wait that subs is cleaned
6219 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6221 xappConn1.TestMsgChanEmpty(t)
6222 e2termConn1.TestMsgChanEmpty(t)
6223 mainCtrl.wait_registry_empty(t, 10)
6224 mainCtrl.VerifyAllClean(t)
6227 //-----------------------------------------------------------------------------
6228 // TestRESTUnpackSubscriptionFailureDecodeFail
6231 // +-------+ +---------+ +---------+
6232 // | xapp | | submgr | | e2term |
6233 // +-------+ +---------+ +---------+
6236 // |---------------->| |
6238 // | RESTSubResp | |
6239 // |<----------------| |
6242 // | |------------->|
6244 // | | SubFail | ASN.1 decode fails
6245 // | |<-------------|
6248 // | |------------->|
6250 // | | SubFail | Duplicated action
6251 // | |<-------------|
6252 // | RESTNotif (fail)| |
6253 // |<----------------| |
6256 //-----------------------------------------------------------------------------
6257 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
6258 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
6259 const subReqCount int = 1
6262 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6263 restSubId := xappConn1.SendRESTSubsReq(t, params)
6265 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6267 // Decode of this response fails which will result resending original request
6268 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
6270 _, cremsg = e2termConn1.RecvSubsReq(t)
6272 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6274 // Subscription already created in E2 Node.
6275 fparams := &teststube2ap.E2StubSubsFailParams{}
6277 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6278 e2termConn1.SendSubsFail(t, fparams, cremsg)
6280 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6281 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6283 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6285 // Wait that subs is cleaned
6286 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6288 xappConn1.TestMsgChanEmpty(t)
6289 e2termConn1.TestMsgChanEmpty(t)
6290 mainCtrl.wait_registry_empty(t, 10)
6291 mainCtrl.VerifyAllClean(t)
6294 //-----------------------------------------------------------------------------
6295 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
6298 // +-------+ +---------+ +---------+
6299 // | xapp | | submgr | | e2term |
6300 // +-------+ +---------+ +---------+
6303 // |---------------->| |
6305 // | RESTSubResp | |
6306 // |<----------------| |
6309 // | |------------->|
6311 // | | SubFail | Unknown instanceId
6312 // | |<-------------|
6315 // | |------------->|
6317 // | | SubFail | Duplicated action
6318 // | |<-------------|
6319 // | RESTNotif (fail)| |
6320 // |<----------------| |
6322 // | |------------->|
6325 // | |<-------------|
6327 //-----------------------------------------------------------------------------
6328 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
6329 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
6330 const subReqCount int = 1
6333 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6334 restSubId := xappConn1.SendRESTSubsReq(t, params)
6336 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6338 // Unknown instanceId in this response which will result resending original request
6339 fparams := &teststube2ap.E2StubSubsFailParams{}
6341 fparams.Fail.RequestId.InstanceId = 0
6342 e2termConn1.SendSubsFail(t, fparams, cremsg)
6344 _, cremsg = e2termConn1.RecvSubsReq(t)
6346 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6348 // Subscription already created in E2 Node.
6349 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6350 e2termConn1.SendSubsFail(t, fparams, cremsg)
6352 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6353 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6355 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6356 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6358 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6360 // Wait that subs is cleaned
6361 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6363 xappConn1.TestMsgChanEmpty(t)
6364 e2termConn1.TestMsgChanEmpty(t)
6365 mainCtrl.wait_registry_empty(t, 10)
6366 mainCtrl.VerifyAllClean(t)
6369 //-----------------------------------------------------------------------------
6370 // TestRESTUnpackSubscriptionFailureNoTransaction
6373 // +-------+ +---------+ +---------+
6374 // | xapp | | submgr | | e2term |
6375 // +-------+ +---------+ +---------+
6378 // |---------------->| |
6380 // | RESTSubResp | |
6381 // |<----------------| |
6384 // | |------------->|
6386 // | | SubFail | No transaction for the response
6387 // | |<-------------|
6390 // | |------------->|
6392 // | | SubFail | Duplicated action
6393 // | |<-------------|
6394 // | RESTNotif (fail)| |
6395 // |<----------------| |
6397 // | |------------->|
6400 // | |<-------------|
6402 //-----------------------------------------------------------------------------
6403 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
6404 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
6405 const subReqCount int = 1
6408 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6409 restSubId := xappConn1.SendRESTSubsReq(t, params)
6411 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6413 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6415 // No transaction exist for this response which will result resending original request
6416 fparams := &teststube2ap.E2StubSubsFailParams{}
6418 e2termConn1.SendSubsFail(t, fparams, cremsg)
6420 _, cremsg = e2termConn1.RecvSubsReq(t)
6422 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6424 // Subscription already created in E2 Node.
6425 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6426 e2termConn1.SendSubsFail(t, fparams, cremsg)
6428 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6429 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6431 // Resending happens because there no transaction
6432 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6433 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6435 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6436 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6438 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6440 // Wait that subs is cleaned
6441 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6443 xappConn1.TestMsgChanEmpty(t)
6444 e2termConn1.TestMsgChanEmpty(t)
6445 mainCtrl.wait_registry_empty(t, 10)
6446 mainCtrl.VerifyAllClean(t)
6449 //-----------------------------------------------------------------------------
6450 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
6453 // +-------+ +---------+ +---------+
6454 // | xapp | | submgr | | e2term |
6455 // +-------+ +---------+ +---------+
6457 // | [SUBS CREATE] |
6460 // | RESTSubDelReq | |
6461 // |---------------->| |
6463 // | RESTSubDelResp | |
6464 // |<----------------| |
6467 // | |------------->|
6469 // | | SubDelResp | ASN.1 decode fails
6470 // | |<-------------|
6473 // | |------------->|
6475 // | | SubDelFail | Subscription does exist any more
6476 // | |<-------------|
6479 //-----------------------------------------------------------------------------
6480 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
6481 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail")
6484 var params *teststube2ap.RESTSubsReqParams = nil
6485 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6488 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6490 // E2t: Receive 1st SubsDelReq
6491 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6493 // Decode of this response fails which will result resending original request
6494 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_REQ)
6496 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6497 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6499 // Subscription does not exist in in E2 Node.
6500 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6502 // Wait that subs is cleaned
6503 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6505 xappConn1.TestMsgChanEmpty(t)
6506 e2termConn1.TestMsgChanEmpty(t)
6507 mainCtrl.wait_registry_empty(t, 10)
6508 mainCtrl.VerifyAllClean(t)
6511 //-----------------------------------------------------------------------------
6512 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
6515 // +-------+ +---------+ +---------+
6516 // | xapp | | submgr | | e2term |
6517 // +-------+ +---------+ +---------+
6519 // | [SUBS CREATE] |
6522 // | RESTSubDelReq | |
6523 // |---------------->| |
6525 // | RESTSubDelResp | |
6526 // |<----------------| |
6529 // | |------------->|
6531 // | | SubDelResp | Unknown instanceId
6532 // | |<-------------|
6535 // | |------------->|
6537 // | | SubDelFail | Subscription does exist any more
6538 // | |<-------------|
6540 //-----------------------------------------------------------------------------
6541 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
6542 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId")
6545 var params *teststube2ap.RESTSubsReqParams = nil
6546 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6549 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6551 // E2t: Receive 1st SubsDelReq
6552 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6554 // Unknown instanceId in this response which will result resending original request
6555 delreq.RequestId.InstanceId = 0
6556 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6558 // E2t: Receive 2nd SubsDelReq
6559 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6561 // Subscription does not exist in in E2 Node.
6562 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6564 // Wait that subs is cleaned
6565 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6567 xappConn1.TestMsgChanEmpty(t)
6568 e2termConn1.TestMsgChanEmpty(t)
6569 mainCtrl.wait_registry_empty(t, 10)
6570 mainCtrl.VerifyAllClean(t)
6573 //-----------------------------------------------------------------------------
6574 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
6577 // +-------+ +---------+ +---------+
6578 // | xapp | | submgr | | e2term |
6579 // +-------+ +---------+ +---------+
6581 // | [SUBS CREATE] |
6584 // | RESTSubDelReq | |
6585 // |---------------->| |
6587 // | RESTSubDelResp | |
6588 // |<----------------| |
6591 // | |------------->|
6593 // | | SubDelResp | No transaction for the response
6594 // | |<-------------|
6597 // | |------------->|
6599 // | | SubDelFail | Subscription does exist any more
6600 // | |<-------------|
6602 //-----------------------------------------------------------------------------
6603 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
6604 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction")
6607 var params *teststube2ap.RESTSubsReqParams = nil
6608 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6611 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6613 // E2t: Receive 1st SubsDelReq
6614 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6616 mainCtrl.MakeTransactionNil(t, e2SubsId)
6618 // No transaction exist for this response which will result resending original request
6619 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6621 // E2t: Receive 2nd SubsDelReq
6622 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6624 // Subscription does not exist in in E2 Node.
6625 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6627 // Wait that subs is cleaned
6628 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6630 xappConn1.TestMsgChanEmpty(t)
6631 e2termConn1.TestMsgChanEmpty(t)
6632 mainCtrl.wait_registry_empty(t, 10)
6633 mainCtrl.VerifyAllClean(t)
6636 //-----------------------------------------------------------------------------
6637 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
6640 // +-------+ +---------+ +---------+
6641 // | xapp | | submgr | | e2term |
6642 // +-------+ +---------+ +---------+
6644 // | [SUBS CREATE] |
6647 // | RESTSubDelReq | |
6648 // |---------------->| |
6650 // | RESTSubDelResp | |
6651 // |<----------------| |
6654 // | |------------->|
6656 // | | SubDelFail | ASN.1 decode fails
6657 // | |<-------------|
6660 // | |------------->|
6662 // | | SubDelFail | Subscription does exist any more
6663 // | |<-------------|
6665 //-----------------------------------------------------------------------------
6666 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
6667 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail")
6670 var params *teststube2ap.RESTSubsReqParams = nil
6671 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6674 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6676 // E2t: Receive 1st SubsDelReq
6677 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6679 // Decode of this response fails which will result resending original request
6680 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
6682 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6683 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6685 // Subscription does not exist in in E2 Node.
6686 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6688 // Wait that subs is cleaned
6689 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6691 xappConn1.TestMsgChanEmpty(t)
6692 e2termConn1.TestMsgChanEmpty(t)
6693 mainCtrl.wait_registry_empty(t, 10)
6694 mainCtrl.VerifyAllClean(t)
6697 //-----------------------------------------------------------------------------
6698 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
6701 // +-------+ +---------+ +---------+
6702 // | xapp | | submgr | | e2term |
6703 // +-------+ +---------+ +---------+
6705 // | [SUBS CREATE] |
6708 // | RESTSubDelReq | |
6709 // |---------------->| |
6711 // | RESTSubDelResp | |
6712 // |<----------------| |
6715 // | |------------->|
6717 // | | SubDelFail | Unknown instanceId
6718 // | |<-------------|
6721 // | |------------->|
6723 // | | SubDelFail | Subscription does exist any more
6724 // | |<-------------|
6726 //-----------------------------------------------------------------------------
6727 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
6728 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId")
6731 var params *teststube2ap.RESTSubsReqParams = nil
6732 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6735 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6737 // E2t: Receive 1st SubsDelReq
6738 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6740 // Unknown instanceId in this response which will result resending original request
6741 delreq.RequestId.InstanceId = 0
6742 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6744 // E2t: Receive 2nd SubsDelReq
6745 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6747 // Subscription does not exist in in E2 Node.
6748 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6750 // Wait that subs is cleaned
6751 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6753 xappConn1.TestMsgChanEmpty(t)
6754 e2termConn1.TestMsgChanEmpty(t)
6755 mainCtrl.wait_registry_empty(t, 10)
6756 mainCtrl.VerifyAllClean(t)
6759 //-----------------------------------------------------------------------------
6760 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
6763 // +-------+ +---------+ +---------+
6764 // | xapp | | submgr | | e2term |
6765 // +-------+ +---------+ +---------+
6767 // | [SUBS CREATE] |
6770 // | RESTSubDelReq | |
6771 // |---------------->| |
6773 // | RESTSubDelResp | |
6774 // |<----------------| |
6777 // | |------------->|
6779 // | | SubDelFail | No transaction for the response
6780 // | |<-------------|
6783 // | |------------->|
6785 // | | SubDelFail | Subscription does exist any more
6786 // | |<-------------|
6788 //-----------------------------------------------------------------------------
6789 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
6790 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction")
6793 var params *teststube2ap.RESTSubsReqParams = nil
6794 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6797 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6799 // E2t: Receive 1st SubsDelReq
6800 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6802 mainCtrl.MakeTransactionNil(t, e2SubsId)
6804 // No transaction exist for this response which will result resending original request
6805 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6807 // E2t: Receive 2nd SubsDelReq
6808 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6810 // Subscription does not exist in in E2 Node.
6811 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6813 // Wait that subs is cleaned
6814 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6816 xappConn1.TestMsgChanEmpty(t)
6817 e2termConn1.TestMsgChanEmpty(t)
6818 mainCtrl.wait_registry_empty(t, 10)
6819 mainCtrl.VerifyAllClean(t)
6822 //-----------------------------------------------------------------------------
6823 // TestRESTSubReqFailAsn1PackSubReqError
6826 // +-------+ +---------+ +---------+
6827 // | xapp | | submgr | | e2term |
6828 // +-------+ +---------+ +---------+
6831 // |---------------->| |
6833 // | RESTSubResp | |
6834 // |<----------------| |
6836 // | ASN.1 encode fails |
6839 // | |------------->|
6842 // | |<-------------|
6846 // |<----------------| |
6848 // | [SUBS DELETE] |
6851 //-----------------------------------------------------------------------------
6852 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
6854 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6855 Counter{cRestSubReqFromXapp, 1},
6856 Counter{cRestSubRespToXapp, 1},
6857 Counter{cRestSubFailNotifToXapp, 1},
6858 Counter{cRestSubDelReqFromXapp, 1},
6859 Counter{cRestSubDelRespToXapp, 1},
6862 const subReqCount int = 1
6864 var params *teststube2ap.RESTSubsReqParams = nil
6865 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
6866 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
6869 restSubId := xappConn1.SendRESTSubsReq(t, params)
6870 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
6872 // E2t: Receive SubsDelReq
6873 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6875 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6876 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
6878 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
6880 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6882 // Wait that subs is cleaned
6883 waitSubsCleanup(t, e2SubsId, 10)
6884 mainCtrl.VerifyCounterValues(t)
6885 mainCtrl.VerifyAllClean(t)
6888 func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
6889 CaseBegin("TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction")
6891 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6892 Counter{cRestSubReqFromXapp, 2},
6893 Counter{cRestSubRespToXapp, 2},
6894 Counter{cSubReqToE2, 2},
6895 Counter{cSubReqTimerExpiry, 1},
6896 Counter{cSubRespFromE2, 1},
6897 Counter{cRestSubNotifToXapp, 1},
6898 Counter{cRestSubFailNotifToXapp, 1},
6899 Counter{cRestSubDelReqFromXapp, 1},
6900 Counter{cSubDelReqToE2, 1},
6901 Counter{cSubDelRespFromE2, 1},
6902 Counter{cRestSubDelRespToXapp, 1},
6905 const e2Timeout int64 = 1
6906 const e2RetryCount int64 = 0
6907 const routingNeeded bool = false
6910 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6911 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6914 restSubId := xappConn1.SendRESTSubsReq(t, params)
6915 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6917 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6918 xappConn1.ExpectRESTNotification(t, restSubId)
6919 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
6920 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6921 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
6924 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6925 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6926 params.SetSubscriptionID(&restSubId)
6927 params.SetTimeToWait("w200ms")
6928 restSubId = xappConn1.SendRESTSubsReq(t, params)
6929 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6931 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
6932 xappConn1.ExpectRESTNotification(t, restSubId)
6933 // SubsResp is missing, e2SubsId will be 0
6934 zeroE2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6935 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", zeroE2SubsId)
6938 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6939 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6940 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6942 waitSubsCleanup(t, e2SubsId, 10)
6944 mainCtrl.VerifyCounterValues(t)
6945 mainCtrl.VerifyAllClean(t)
6948 //-----------------------------------------------------------------------------
6949 // TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle
6952 // +-------+ +---------+ +---------+
6953 // | xapp | | submgr | | e2term |
6954 // +-------+ +---------+ +---------+
6957 // |---------------->| |
6959 // | RESTSubResp | |
6960 // |<----------------| |
6962 // | |------------->|
6965 // | |<-------------|
6968 // |<----------------| |
6971 // |---------------->| |
6973 // | RESTSubResp | |
6974 // |<----------------| |
6976 // | |------------->|
6978 // | Submgr restart |
6980 // | RESTSubDelReq | |
6981 // |---------------->| |
6984 // | |------------->|
6987 // | |<-------------|
6989 // | RESTSubDelResp | |
6990 // |<----------------| |
6992 //-----------------------------------------------------------------------------
6994 func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
6995 CaseBegin("TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle")
6997 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6998 Counter{cRestSubReqFromXapp, 2},
6999 Counter{cRestSubRespToXapp, 2},
7000 Counter{cSubReqToE2, 2},
7001 Counter{cSubRespFromE2, 1},
7002 Counter{cRestSubNotifToXapp, 1},
7003 Counter{cRestSubDelReqFromXapp, 1},
7004 Counter{cSubDelReqToE2, 1},
7005 Counter{cSubDelRespFromE2, 1},
7006 Counter{cRestSubDelRespToXapp, 1},
7009 const e2Timeout int64 = 1
7010 const e2RetryCount int64 = 0
7011 const routingNeeded bool = false
7014 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7015 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7016 // Create subscription
7017 restSubId := xappConn1.SendRESTSubsReq(t, params)
7018 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
7020 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7021 xappConn1.ExpectRESTNotification(t, restSubId)
7022 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
7023 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7024 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7026 // Check subscription
7027 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
7030 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7031 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7032 params.SetSubscriptionID(&restSubId)
7033 params.SetTimeToWait("w200ms")
7034 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
7035 restSubId = xappConn1.SendRESTSubsReq(t, params)
7036 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
7038 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
7039 mainCtrl.SetResetTestFlag(t, false)
7041 // SubsResp is missing due to submgr restart
7043 mainCtrl.SimulateRestart(t)
7044 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
7046 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
7047 // That needs to be completed before successful subscription query is possible
7048 <-time.After(time.Second * 1)
7050 // Check subscription
7051 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
7053 // Delete subscription
7054 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7055 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7056 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7058 //Wait that subs is cleaned
7059 waitSubsCleanup(t, e2SubsId, 10)
7061 mainCtrl.VerifyCounterValues(t)
7062 mainCtrl.VerifyAllClean(t)
7065 ////////////////////////////////////////////////////////////////////////////////////
7066 // Services for UT cases
7067 ////////////////////////////////////////////////////////////////////////////////////
7068 const subReqCount int = 1
7069 const host string = "localhost"
7071 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
7073 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
7075 restSubId := fromXappConn.SendRESTSubsReq(t, params)
7076 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
7078 crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
7079 fromXappConn.ExpectRESTNotification(t, restSubId)
7080 toE2termConn.SendSubsResp(t, crereq1, cremsg1)
7081 e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
7082 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7084 return restSubId, e2SubsId
7087 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
7089 params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
7091 params.SetMeid(meid)
7093 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
7094 restSubId := xappConn2.SendRESTSubsReq(t, params)
7095 xappConn2.ExpectRESTNotification(t, restSubId)
7096 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
7097 e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
7098 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7100 return restSubId, e2SubsId
7103 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
7105 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7106 restSubId := xappConn1.SendRESTSubsReq(t, params)
7107 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
7109 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7110 xappConn1.ExpectRESTNotification(t, restSubId)
7111 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
7112 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7113 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7115 return restSubId, e2SubsId
7118 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
7119 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7120 restSubId := xappConn1.SendRESTSubsReq(t, params)
7122 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7123 fparams1 := &teststube2ap.E2StubSubsFailParams{}
7124 fparams1.Set(crereq1)
7125 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
7127 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
7128 xappConn1.ExpectRESTNotification(t, restSubId)
7129 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
7130 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7131 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
7133 return restSubId, e2SubsId
7136 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
7137 fromXappConn.SendRESTSubsDelReq(t, restSubId)
7138 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
7139 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
7142 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
7143 xappConn1.SendRESTSubsDelReq(t, restSubId)
7144 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7145 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7148 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
7149 xappConn2.SendRESTSubsDelReq(t, restSubId)
7150 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7151 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7154 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
7155 resp, _ := xapp.Subscription.QuerySubscriptions()
7156 assert.Equal(t, e2SubsId, resp[0].SubscriptionID)
7157 assert.Equal(t, meid, resp[0].Meid)
7158 assert.Equal(t, endpoint, resp[0].ClientEndpoint)
7161 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
7162 //Wait that subs is cleaned
7163 mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
7165 xappConn1.TestMsgChanEmpty(t)
7166 xappConn2.TestMsgChanEmpty(t)
7167 e2termConn1.TestMsgChanEmpty(t)
7168 mainCtrl.wait_registry_empty(t, timeout)
7171 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
7173 var e2SubsId []uint32
7175 for i := 0; i < count; i++ {
7176 xapp.Logger.Debug("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
7177 crereq, cremsg := toE2termConn.RecvSubsReq(t)
7178 fromXappConn.ExpectRESTNotification(t, restSubId)
7179 toE2termConn.SendSubsResp(t, crereq, cremsg)
7180 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
7181 e2SubsId = append(e2SubsId, instanceId)
7182 xapp.Logger.Debug("TEST: %v", e2SubsId)
7183 xapp.Logger.Debug("TEST: %d ===================================== END CRE ============================================", i+1)
7184 <-time.After(100 * time.Millisecond)
7189 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
7191 for i := 0; i < len(e2SubsIds); i++ {
7192 xapp.Logger.Debug("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
7193 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
7194 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
7195 <-time.After(1 * time.Second)
7196 xapp.Logger.Debug("TEST: %d ===================================== END DEL ============================================", i+1)
7197 <-time.After(100 * time.Millisecond)
7200 // Wait that subs is cleaned
7201 for i := 0; i < len(e2SubsIds); i++ {
7202 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)