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 // In below test cases there is done only one retry for E2 messages
37 // In Helm chart retry count is currently 2 By default. Retry count
38 // used in test cases is defined in submgr-config.yaml file.
40 func TestSuiteSetup(t *testing.T) {
41 // The effect of this call shall endure though the UT suite!
42 // If this causes any issues, the previous interface can be restored
44 // SetPackerIf(e2ap_wrapper.NewAsn1E2APPacker())
46 mainCtrl.InitAllCounterMap()
47 SetPackerIf(e2ap_wrapper.NewUtAsn1E2APPacker())
48 mainCtrl.c.restDuplicateCtrl.Init()
51 func TestRanStatusChangeViaSDLNotification(t *testing.T) {
53 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
54 Counter{cE2StateChangedToUp, 3},
57 // Current UT test cases use these ran names
58 xappRnibMock.CreateGnb("RAN_NAME_1", entities.ConnectionStatus_DISCONNECTED)
59 xappRnibMock.CreateGnb("RAN_NAME_11", entities.ConnectionStatus_DISCONNECTED)
60 xappRnibMock.CreateGnb("RAN_NAME_2", entities.ConnectionStatus_DISCONNECTED)
62 mainCtrl.c.e2IfState.ReadE2ConfigurationFromRnib()
63 mainCtrl.c.e2IfState.SubscribeChannels()
65 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
66 mainCtrl.SetE2State(t, "RAN_NAME_2_CONNECTED")
67 mainCtrl.SetE2State(t, "RAN_NAME_11_CONNECTED")
69 mainCtrl.VerifyCounterValues(t)
72 //-----------------------------------------------------------------------------
73 // TestRESTSubReqAfterE2ConnBreak
76 // +-------+ +---------+ +---------+
77 // | xapp | | submgr | | e2term |
78 // +-------+ +---------+ +---------+
80 // | [E2 Conn. DOWN] |
83 // |---------------->| |
85 // |<----------------| |
88 //-----------------------------------------------------------------------------
90 func TestRESTSubReqAfterE2ConnBreak(t *testing.T) {
92 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
93 Counter{cRestSubReqFromXapp, 1},
94 Counter{cRestReqRejDueE2Down, 1},
95 Counter{cE2StateChangedToDown, 1},
96 Counter{cE2StateChangedToUp, 1},
99 // E2 disconnect after E2term has received response
100 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
102 const subReqCount int = 1
103 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
104 xappConn1.SendRESTSubsReq(t, params)
106 // Restore E2 connection for following test cases
107 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
109 mainCtrl.VerifyAllClean(t)
110 mainCtrl.VerifyCounterValues(t)
113 //-----------------------------------------------------------------------------
114 // TestRESTSubReqE2ConnBreak
117 // +-------+ +---------+ +---------+
118 // | xapp | | submgr | | e2term |
119 // +-------+ +---------+ +---------+
122 // |---------------->| |
124 // |<----------------| |
126 // | |------------->|
128 // | |<-------------|
130 // | [E2 Conn. DOWN] |
131 // | [Int. SUBS DELETE] |
133 // | RESTNotif(unsuccessful) |
134 // |<----------------| |
138 //-----------------------------------------------------------------------------
139 func TestRESTSubReqE2ConnBreak(t *testing.T) {
141 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
142 Counter{cRestSubReqFromXapp, 1},
143 Counter{cRestSubRespToXapp, 1},
144 Counter{cSubReqToE2, 1},
145 Counter{cSubRespFromE2, 1},
146 Counter{cRestSubFailNotifToXapp, 1},
147 Counter{cE2StateChangedToDown, 1},
148 Counter{cE2StateChangedToUp, 1},
152 const subReqCount int = 1
153 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
154 restSubId := xappConn1.SendRESTSubsReq(t, params)
156 crereq, cremsg := e2termConn1.RecvSubsReq(t)
157 xappConn1.ExpectRESTNotification(t, restSubId)
159 // E2 disconnect after E2term has received response
160 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
162 e2termConn1.SendSubsResp(t, crereq, cremsg)
163 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
165 <-time.After(time.Second * 1)
166 assert.Equal(t, 0, len(mainCtrl.c.registry.register))
167 assert.Equal(t, 0, len(mainCtrl.c.registry.restSubscriptions))
169 subIds, register, err := mainCtrl.c.ReadAllSubscriptionsFromSdl()
171 xapp.Logger.Error("%v", err)
173 assert.Equal(t, 65534, len(subIds)) // range 1-65535 , FFFF = 65535
174 assert.Equal(t, 0, len(register))
177 restSubscriptions, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
179 xapp.Logger.Error("%v", err)
181 assert.Equal(t, 0, len(restSubscriptions))
184 // Restore E2 connection for following test cases
185 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
187 // Wait that subs is cleaned
188 waitSubsCleanup(t, e2SubsId, 10)
189 mainCtrl.VerifyCounterValues(t)
190 mainCtrl.VerifyAllClean(t)
193 //-----------------------------------------------------------------------------
194 // TestRESTSubscriptionDeleteAfterE2ConnectionBreak
197 // +-------+ +---------+ +---------+
198 // | xapp | | submgr | | e2term |
199 // +-------+ +---------+ +---------+
203 // | [E2 Conn. DOWN] |
205 // | RESTSubDelReq | |
206 // |---------------->| |
208 // | RESTSubDelResp | |
209 // |<----------------| |
211 // | [No valid subscription found] |
214 //-----------------------------------------------------------------------------
215 func TestRESTSubscriptionDeleteAfterE2ConnectionBreak(t *testing.T) {
216 xapp.Logger.Debug("TEST: TestRESTSubscriptionDeleteAfterE2ConnectionBreak")
218 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
219 Counter{cRestSubReqFromXapp, 1},
220 Counter{cRestSubRespToXapp, 1},
221 Counter{cSubReqToE2, 1},
222 Counter{cSubRespFromE2, 1},
223 Counter{cRestSubNotifToXapp, 1},
224 Counter{cRestSubDelReqFromXapp, 1},
225 Counter{cRestSubDelRespToXapp, 1},
226 Counter{cE2StateChangedToDown, 1},
227 Counter{cE2StateChangedToUp, 1},
231 var params *teststube2ap.RESTSubsReqParams = nil
232 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
234 // E2 disconnect after E2term has received response
235 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
238 xappConn1.SendRESTSubsDelReq(t, &restSubId)
240 <-time.After(time.Second * 1)
241 assert.Equal(t, 0, len(mainCtrl.c.registry.register))
242 assert.Equal(t, 0, len(mainCtrl.c.registry.restSubscriptions))
244 subIds, register, err := mainCtrl.c.ReadAllSubscriptionsFromSdl()
246 xapp.Logger.Error("%v", err)
248 assert.Equal(t, 65534, len(subIds)) // range 1-65535 , FFFF = 65535
249 assert.Equal(t, 0, len(register))
252 restSubscriptions, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
254 xapp.Logger.Error("%v", err)
256 assert.Equal(t, 0, len(restSubscriptions))
259 // Restore E2 connection for following test cases
260 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
262 // Wait that subs is cleaned
263 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
265 xappConn1.TestMsgChanEmpty(t)
266 e2termConn1.TestMsgChanEmpty(t)
267 mainCtrl.wait_registry_empty(t, 10)
268 mainCtrl.VerifyCounterValues(t)
269 mainCtrl.VerifyAllClean(t)
272 //-----------------------------------------------------------------------------
273 // TestRESTOtherE2ConnectionChanges
277 // +-------+ +---------+ +---------+
278 // | xapp | | submgr | | e2term |
279 // +-------+ +---------+ +---------+
283 // | [E2 CONNECTED_SETUP_FAILED] |
284 // | [E2 CONNECTING] |
285 // | [E2 SHUTTING_DOWN] |
286 // | [E2 SHUT_DOWN] |
291 //-----------------------------------------------------------------------------
292 func TestRESTOtherE2ConnectionChanges(t *testing.T) {
293 xapp.Logger.Debug("TEST: TestRESTOtherE2ConnectionChanges")
295 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
296 Counter{cRestSubReqFromXapp, 1},
297 Counter{cRestSubRespToXapp, 1},
298 Counter{cSubReqToE2, 1},
299 Counter{cSubRespFromE2, 1},
300 Counter{cRestSubNotifToXapp, 1},
301 Counter{cRestSubDelReqFromXapp, 1},
302 Counter{cSubDelReqToE2, 1},
303 Counter{cSubDelRespFromE2, 1},
304 Counter{cRestSubDelRespToXapp, 1},
305 Counter{cE2StateChangedToUp, 1},
309 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
310 restSubId := xappConn1.SendRESTSubsReq(t, params)
312 crereq, cremsg := e2termConn1.RecvSubsReq(t)
313 xappConn1.ExpectRESTNotification(t, restSubId)
314 e2termConn1.SendSubsResp(t, crereq, cremsg)
315 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
317 // Submgr should not react to any other connection state changes than CONNECTED and DISCONNECTED
318 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED_SETUP_FAILED")
319 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTING")
320 mainCtrl.SetE2State(t, "RAN_NAME_1_SHUTTING_DOWN")
321 mainCtrl.SetE2State(t, "RAN_NAME_1_SHUT_DOWN")
324 xappConn1.SendRESTSubsDelReq(t, &restSubId)
325 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
326 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
328 // Restore E2 connection for following test cases
329 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
331 // Wait that subs is cleaned
332 waitSubsCleanup(t, e2SubsId, 10)
333 mainCtrl.VerifyCounterValues(t)
334 mainCtrl.VerifyAllClean(t)
337 //-----------------------------------------------------------------------------
338 // TestRESTSubReqAndDeleteOkWithE2apUtWrapper
341 // +-------+ +---------+ +---------+ +---------+
342 // | xapp | | submgr | | e2term | | rtmgr |
343 // +-------+ +---------+ +---------+ +---------+
345 // | RESTSubReq | | |
346 // |---------------->| | |
347 // | | RouteCreate | |
348 // | |--------------------------->| // The order of these events may vary
350 // | RESTSubResp | | | // The order of these events may vary
351 // |<----------------| | |
352 // | | RouteResponse| |
353 // | |<---------------------------| // The order of these events may vary
356 // | |------------->| | // The order of these events may vary
359 // | |<-------------| |
360 // | RESTNotif1 | | |
361 // |<----------------| | |
363 // | RESTSubDelReq | | |
364 // |---------------->| | |
366 // | |------------->| |
368 // | RESTSubDelResp| | |
369 // |<----------------| | |
371 // | | SubDelResp | |
372 // | |<-------------| |
376 //-----------------------------------------------------------------------------
377 func TestRESTSubReqAndDeleteOkWithE2apUtWrapper(t *testing.T) {
379 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
381 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
383 waitSubsCleanup(t, e2SubsId, 10)
384 mainCtrl.VerifyAllClean(t)
387 //-----------------------------------------------------------------------------
388 // TestRESTSubReqAndE1apDeleteReqPackingError
391 // +-------+ +---------+ +---------+ +---------+
392 // | xapp | | submgr | | e2term | | rtmgr |
393 // +-------+ +---------+ +---------+ +---------+
395 // | RESTSubReq | | |
396 // |---------------->| | |
397 // | | RouteCreate | |
398 // | |--------------------------->| // The order of these events may vary
400 // | RESTSubResp | | | // The order of these events may vary
401 // |<----------------| | |
402 // | | RouteResponse| |
403 // | |<---------------------------| // The order of these events may vary
406 // | |------------->| | // The order of these events may vary
409 // | |<-------------| |
410 // | RESTNotif1 | | |
411 // |<----------------| | |
413 // | RESTSubDelReq | | |
414 // |---------------->| | |
416 // | RESTSubDelResp| | |
417 // |<----------------| | |
421 //-----------------------------------------------------------------------------
422 func TestRESTSubReqAndE1apDeleteReqPackingError(t *testing.T) {
424 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
426 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, false)
427 xappConn1.SendRESTSubsDelReq(t, &restSubId)
428 defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, true)
430 waitSubsCleanup(t, e2SubsId, 10)
431 mainCtrl.VerifyAllClean(t)
434 //-----------------------------------------------------------------------------
435 // TestRESTSubReqAndE2APDeleteRespUnpackingError
438 // +-------+ +---------+ +---------+ +---------+
439 // | xapp | | submgr | | e2term | | rtmgr |
440 // +-------+ +---------+ +---------+ +---------+
442 // | RESTSubReq | | |
443 // |---------------->| | |
444 // | | RouteCreate | |
445 // | |--------------------------->| // The order of these events may vary
447 // | RESTSubResp | | | // The order of these events may vary
448 // |<----------------| | |
449 // | | RouteResponse| |
450 // | |<---------------------------| // The order of these events may vary
453 // | |------------->| | // The order of these events may vary
456 // | |<-------------| |
457 // | RESTNotif1 | | |
458 // |<----------------| | |
460 // | RESTSubDelReq | | |
461 // |---------------->| | |
463 // | |------------->| |
465 // | RESTSubDelResp| | |
466 // |<----------------| | | // The order of these events may vary
468 // | | SubDelResp | |
469 // | |<-------------| | // 1.st NOK
472 // | |------------->| |
474 // | | SubDelResp | |
475 // | |<-------------| | // 2.nd NOK
477 //-----------------------------------------------------------------------------
479 func TestRESTSubReqAndE2APDeleteRespUnpackingError(t *testing.T) {
481 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
483 xappConn1.SendRESTSubsDelReq(t, &restSubId)
484 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, false)
485 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
486 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
488 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
489 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
491 defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, true)
493 waitSubsCleanup(t, e2SubsId, 10)
494 mainCtrl.VerifyAllClean(t)
497 //-----------------------------------------------------------------------------
498 // TestSubReqAndRouteNok
501 // +-------+ +---------+ +---------+
502 // | xapp | | submgr | | rtmgr |
503 // +-------+ +---------+ +---------+
506 // |------------->| |
509 // | |------------->|
513 // | |<-------------|
515 // | [SUBS INT DELETE] |
518 //-----------------------------------------------------------------------------
520 func TestSubReqAndRouteNok(t *testing.T) {
521 CaseBegin("TestSubReqAndRouteNok")
523 // Init counter check
524 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
525 Counter{cSubReqFromXapp, 1},
526 Counter{cRouteCreateFail, 1},
529 waiter := rtmgrHttp.AllocNextEvent(false)
530 newSubsId := mainCtrl.get_registry_next_subid(t)
531 xappConn1.SendSubsReq(t, nil, nil)
534 //Wait that subs is cleaned
535 mainCtrl.wait_subs_clean(t, newSubsId, 10)
537 xappConn1.TestMsgChanEmpty(t)
538 xappConn2.TestMsgChanEmpty(t)
539 e2termConn1.TestMsgChanEmpty(t)
540 mainCtrl.wait_registry_empty(t, 10)
542 <-time.After(1 * time.Second)
543 mainCtrl.VerifyCounterValues(t)
546 //-----------------------------------------------------------------------------
547 // TestSubReqAndRouteUpdateNok
550 // +-------+ +-------+ +---------+ +---------+
551 // | xapp2 | | xapp1 | | submgr | | rtmgr |
552 // +-------+ +-------+ +---------+ +---------+
554 // | [SUBS CREATE] | |
558 // | SubReq (mergeable) | |
559 // |--------------------------->| | |
561 // | | | RouteUpdate |
562 // | | |------------->|
564 // | | | RouteUpdate |
565 // | | | status:400 |
566 // | | |<-------------|
568 // | [SUBS INT DELETE] | |
571 // | [SUBS DELETE] | |
574 func TestSubReqAndRouteUpdateNok(t *testing.T) {
575 CaseBegin("TestSubReqAndRouteUpdateNok")
577 // Init counter check
578 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
579 Counter{cSubReqFromXapp, 2},
580 Counter{cSubReqToE2, 1},
581 Counter{cSubRespFromE2, 1},
582 Counter{cSubRespToXapp, 1},
583 Counter{cRouteCreateUpdateFail, 1},
584 Counter{cSubDelReqFromXapp, 1},
585 Counter{cSubDelReqToE2, 1},
586 Counter{cSubDelRespFromE2, 1},
587 Counter{cSubDelRespToXapp, 1},
590 cretrans := xappConn1.SendSubsReq(t, nil, nil)
591 crereq, cremsg := e2termConn1.RecvSubsReq(t)
592 e2termConn1.SendSubsResp(t, crereq, cremsg)
593 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
595 resp, _ := xapp.Subscription.QuerySubscriptions()
596 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
597 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
598 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
600 waiter := rtmgrHttp.AllocNextEvent(false)
601 newSubsId := mainCtrl.get_registry_next_subid(t)
602 xappConn2.SendSubsReq(t, nil, nil)
605 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
606 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
608 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
609 xappConn1.RecvSubsDelResp(t, deltrans)
611 //Wait that subs is cleaned
612 mainCtrl.wait_subs_clean(t, newSubsId, 10)
613 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
615 xappConn1.TestMsgChanEmpty(t)
616 xappConn2.TestMsgChanEmpty(t)
617 e2termConn1.TestMsgChanEmpty(t)
618 mainCtrl.wait_registry_empty(t, 10)
620 mainCtrl.VerifyCounterValues(t)
623 //-----------------------------------------------------------------------------
624 // TestSubDelReqAndRouteDeleteNok
627 // +-------+ +---------+ +---------+ +---------+
628 // | xapp | | submgr | | e2term | | rtmgr |
629 // +-------+ +---------+ +---------+ +---------+
631 // | [SUBS CREATE] | |
636 // |------------->| | |
638 // | |------------->| |
640 // | |<-------------| |
642 // |<-------------| | |
643 // | | RouteDelete | |
644 // | |---------------------------->|
646 // | | RouteDelete | |
647 // | | status:400 | |
648 // | |<----------------------------|
650 func TestSubDelReqAndRouteDeleteNok(t *testing.T) {
651 CaseBegin("TestSubDelReqAndRouteDeleteNok")
653 // Init counter check
654 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
655 Counter{cSubReqFromXapp, 1},
656 Counter{cSubReqToE2, 1},
657 Counter{cSubRespFromE2, 1},
658 Counter{cSubRespToXapp, 1},
659 Counter{cSubDelReqFromXapp, 1},
660 Counter{cRouteDeleteFail, 1},
661 Counter{cSubDelReqToE2, 1},
662 Counter{cSubDelRespFromE2, 1},
663 Counter{cSubDelRespToXapp, 1},
666 cretrans := xappConn1.SendSubsReq(t, nil, nil)
667 crereq, cremsg := e2termConn1.RecvSubsReq(t)
668 e2termConn1.SendSubsResp(t, crereq, cremsg)
669 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
671 resp, _ := xapp.Subscription.QuerySubscriptions()
672 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
673 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
674 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
676 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
677 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
679 waiter := rtmgrHttp.AllocNextEvent(false)
680 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
683 xappConn1.RecvSubsDelResp(t, deltrans)
685 //Wait that subs is cleaned
686 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
688 xappConn1.TestMsgChanEmpty(t)
689 xappConn2.TestMsgChanEmpty(t)
690 e2termConn1.TestMsgChanEmpty(t)
691 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 // TestDelAllE2nodeSubsViaDebugIf
2663 // +-------+ +---------+ +---------+ +---------+
2664 // | xapp | | submgr | | e2term | | rtmgr |
2665 // +-------+ +---------+ +---------+ +---------+
2667 // | RESTSubReq | | |
2668 // |---------------->| | |
2669 // | RESTSubResp | | |
2670 // |<----------------| | |
2671 // | | RouteCreate | |
2672 // | |--------------------------->|
2673 // | | RouteResponse| |
2674 // | |<---------------------------|
2676 // | |------------->| |
2678 // | |<-------------| |
2679 // | RESTNotif1 | | |
2680 // |<----------------| | |
2682 // | REST get_all_e2nodes | |
2683 // |---------------->| | |
2685 // |<----------------| | |
2686 // | REST delete_all_e2node_subscriptions | ranName = RAN_NAME_1
2687 // |---------------->| | |
2689 // |<----------------| | |
2690 // | | SubDelReq | |
2691 // | |------------->| |
2692 // | | SubDelResp | |
2693 // | |<-------------| |
2695 // | | RouteDelete | |
2696 // | |--------------------------->|
2697 // | | RouteResponse| |
2698 // | |<---------------------------|
2700 //-----------------------------------------------------------------------------
2702 func TestDelAllE2nodeSubsViaDebugIf(t *testing.T) {
2704 // Init counter check
2705 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2706 Counter{cRestSubReqFromXapp, 1},
2707 Counter{cRestSubRespToXapp, 1},
2708 Counter{cSubReqToE2, 1},
2709 Counter{cSubRespFromE2, 1},
2710 Counter{cRestSubNotifToXapp, 1},
2711 Counter{cRestSubDelReqFromXapp, 1},
2712 Counter{cSubDelReqToE2, 1},
2713 Counter{cSubDelRespFromE2, 1},
2714 Counter{cRestSubDelRespToXapp, 1},
2717 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2718 restSubId := xappConn1.SendRESTSubsReq(t, params)
2719 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
2721 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2722 xappConn1.ExpectRESTNotification(t, restSubId)
2723 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2724 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2725 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
2727 e2nodesJson := mainCtrl.SendGetRequest(t, "localhost:8080", "/ric/v1/get_all_e2nodes")
2729 var e2nodesList []string
2730 err := json.Unmarshal(e2nodesJson, &e2nodesList)
2732 t.Errorf("Unmarshal error: %s", err)
2734 assert.Equal(t, true, mainCtrl.VerifyStringExistInSlice("RAN_NAME_1", e2nodesList))
2736 e2RestSubsJson := mainCtrl.SendGetRequest(t, "localhost:8080", "/ric/v1/get_e2node_rest_subscriptions/RAN_NAME_1") // RAN_NAME_1 = ranName
2737 var e2RestSubsMap map[string]RESTSubscription
2738 err = json.Unmarshal(e2RestSubsJson, &e2RestSubsMap)
2740 t.Errorf("Unmarshal error: %s", err)
2743 if len(e2RestSubsMap) != 1 {
2744 t.Errorf("Incorrect e2RestSubsMap length %v", len(e2RestSubsMap))
2747 // Simulate deletion through REST test and debug interface
2748 mainCtrl.SendDeleteRequest(t, "localhost:8080", "/ric/v1/delete_all_e2node_subscriptions/RAN_NAME_1") // RAN_NAME_1 = ranName
2749 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2750 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2752 // Wait that subs is cleaned
2753 waitSubsCleanup(t, e2SubsId, 10)
2754 mainCtrl.VerifyCounterValues(t)
2755 mainCtrl.VerifyAllClean(t)
2758 //-----------------------------------------------------------------------------
2759 // TestDelAllxAppSubsViaDebugIf
2762 // +-------+ +---------+ +---------+ +---------+
2763 // | xapp | | submgr | | e2term | | rtmgr |
2764 // +-------+ +---------+ +---------+ +---------+
2766 // | RESTSubReq | | |
2767 // |---------------->| | |
2768 // | RESTSubResp | | |
2769 // |<----------------| | |
2770 // | | RouteCreate | |
2771 // | |--------------------------->|
2772 // | | RouteResponse| |
2773 // | |<---------------------------|
2775 // | |------------->| |
2777 // | |<-------------| |
2778 // | RESTNotif1 | | |
2779 // |<----------------| | |
2781 // | REST get_all_xapps | |
2782 // |---------------->| | |
2784 // |<----------------| | |
2785 // | REST delete_all_xapp_subscriptions | xappServiceName = localhost
2786 // |---------------->| | |
2788 // |<----------------| | |
2789 // | | SubDelReq | |
2790 // | |------------->| |
2791 // | | SubDelResp | |
2792 // | |<-------------| |
2794 // | | RouteDelete | |
2795 // | |--------------------------->|
2796 // | | RouteResponse| |
2797 // | |<---------------------------|
2799 //-----------------------------------------------------------------------------
2801 func TestDelAllxAppSubsViaDebugIf(t *testing.T) {
2803 // Init counter check
2804 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2805 Counter{cRestSubReqFromXapp, 1},
2806 Counter{cRestSubRespToXapp, 1},
2807 Counter{cSubReqToE2, 1},
2808 Counter{cSubRespFromE2, 1},
2809 Counter{cRestSubNotifToXapp, 1},
2810 Counter{cRestSubDelReqFromXapp, 1},
2811 Counter{cSubDelReqToE2, 1},
2812 Counter{cSubDelRespFromE2, 1},
2813 Counter{cRestSubDelRespToXapp, 1},
2816 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2817 restSubId := xappConn1.SendRESTSubsReq(t, params)
2818 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
2820 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2821 xappConn1.ExpectRESTNotification(t, restSubId)
2822 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2823 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2824 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
2826 xappsJson := mainCtrl.SendGetRequest(t, "localhost:8080", "/ric/v1/get_all_xapps")
2828 var xappList []string
2829 err := json.Unmarshal(xappsJson, &xappList)
2831 t.Errorf("Unmarshal error: %s", err)
2833 assert.Equal(t, true, mainCtrl.VerifyStringExistInSlice("localhost", xappList))
2835 // Simulate deletion through REST test and debug interface
2836 mainCtrl.SendDeleteRequest(t, "localhost:8080", "/ric/v1/delete_all_xapp_subscriptions/localhost") // localhost = xappServiceName
2837 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2838 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2840 // Wait that subs is cleaned
2841 waitSubsCleanup(t, e2SubsId, 10)
2842 mainCtrl.VerifyCounterValues(t)
2843 mainCtrl.VerifyAllClean(t)
2846 //-----------------------------------------------------------------------------
2847 // TestDelViaxAppSubsIf
2850 // +-------+ +---------+ +---------+ +---------+
2851 // | xapp | | submgr | | e2term | | rtmgr |
2852 // +-------+ +---------+ +---------+ +---------+
2854 // | RESTSubReq | | |
2855 // |---------------->| | |
2856 // | RESTSubResp | | |
2857 // |<----------------| | |
2858 // | | RouteCreate | |
2859 // | |--------------------------->|
2860 // | | RouteResponse| |
2861 // | |<---------------------------|
2863 // | |------------->| |
2865 // | |<-------------| |
2866 // | RESTNotif1 | | |
2867 // |<----------------| | |
2869 // | REST get_xapp_rest_restsubscriptions |
2870 // |---------------->| | |
2872 // |<----------------| | |
2873 // | RESTSudDel | | |
2874 // |---------------->| | | Via user curl command (port 8088)
2875 // | RESTSudDel | | |
2876 // |<----------------| | |
2877 // | | SubDelReq | |
2878 // | |------------->| |
2879 // | | SubDelResp | |
2880 // | |<-------------| |
2882 // | | RouteDelete | |
2883 // | |--------------------------->|
2884 // | | RouteResponse| |
2885 // | |<---------------------------|
2887 //-----------------------------------------------------------------------------
2889 func TestDelViaxAppSubsIf(t *testing.T) {
2891 // Init counter check
2892 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2893 Counter{cRestSubReqFromXapp, 1},
2894 Counter{cRestSubRespToXapp, 1},
2895 Counter{cSubReqToE2, 1},
2896 Counter{cSubRespFromE2, 1},
2897 Counter{cRestSubNotifToXapp, 1},
2898 Counter{cRestSubDelReqFromXapp, 1},
2899 Counter{cSubDelReqToE2, 1},
2900 Counter{cSubDelRespFromE2, 1},
2901 Counter{cRestSubDelRespToXapp, 1},
2904 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2905 restSubId := xappConn1.SendRESTSubsReq(t, params)
2906 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
2908 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2909 xappConn1.ExpectRESTNotification(t, restSubId)
2910 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2911 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2912 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
2914 restSubsListJson := mainCtrl.SendGetRequest(t, "localhost:8080", "/ric/v1/get_xapp_rest_restsubscriptions/localhost") // localhost = xappServiceName
2916 var restSubsMap map[string]RESTSubscription
2917 err := json.Unmarshal(restSubsListJson, &restSubsMap)
2919 t.Errorf("Unmarshal error: %s", err)
2921 _, ok := restSubsMap[restSubId]
2923 t.Errorf("REST subscription not found. restSubId=%s", restSubId)
2926 var e2Subscriptions []Subscription
2927 e2SubscriptionsJson := mainCtrl.SendGetRequest(t, "localhost:8080", "/ric/v1/get_e2subscriptions/"+restSubId)
2928 err = json.Unmarshal(e2SubscriptionsJson, &e2Subscriptions)
2930 t.Errorf("Unmarshal error: %s", err)
2932 if len(e2Subscriptions) != 1 {
2933 t.Errorf("Incorrect e2Subscriptions length %v", len(e2Subscriptions))
2936 // Simulate deletion through xapp REST test interface
2937 mainCtrl.SendDeleteRequest(t, "localhost:8088", "/ric/v1/subscriptions/"+restSubId)
2938 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2939 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2941 // Wait that subs is cleaned
2942 waitSubsCleanup(t, e2SubsId, 10)
2943 mainCtrl.VerifyCounterValues(t)
2944 mainCtrl.VerifyAllClean(t)
2947 //-----------------------------------------------------------------------------
2948 // TestRESTSubReqAndRouteNok
2951 // +-------+ +---------+ +---------+
2952 // | xapp | | submgr | | rtmgr |
2953 // +-------+ +---------+ +---------+
2956 // |---------------->| |
2958 // | RESTSubResp | |
2959 // |<----------------| |
2960 // | | RouteCreate |
2961 // | |------------->|
2962 // | | RouteCreate |
2964 // | |(Bad request) |
2965 // | |<-------------|
2967 // |<----------------| |
2969 // | [SUBS INT DELETE] |
2971 // | RESTSubDelReq | |
2972 // |---------------->| |
2973 // | RESTSubDelResp | |
2974 // |<----------------| |
2976 //-----------------------------------------------------------------------------
2977 func TestRESTSubReqAndRouteNok(t *testing.T) {
2979 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2980 Counter{cRestSubReqFromXapp, 1},
2981 Counter{cRestSubRespToXapp, 1},
2982 Counter{cRouteCreateFail, 1},
2983 Counter{cRestSubFailNotifToXapp, 1},
2984 Counter{cRestSubDelReqFromXapp, 1},
2985 Counter{cRestSubDelRespToXapp, 1},
2988 const subReqCount int = 1
2990 // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
2991 waiter := rtmgrHttp.AllocNextSleep(50, false)
2992 newSubsId := mainCtrl.get_registry_next_subid(t)
2995 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2996 restSubId := xappConn1.SendRESTSubsReq(t, params)
2997 xappConn1.ExpectRESTNotificationNok(t, restSubId, "failAll")
2998 waiter.WaitResult(t)
3000 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3001 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
3004 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3006 // Wait that subs is cleaned
3007 mainCtrl.wait_subs_clean(t, newSubsId, 10)
3008 waitSubsCleanup(t, e2SubsId, 10)
3009 mainCtrl.VerifyCounterValues(t)
3010 mainCtrl.VerifyAllClean(t)
3013 //-----------------------------------------------------------------------------
3014 // TestRESTSubReqAndRouteUpdateNok
3016 // stub stub stub stub
3017 // +-------+ +-------+ +---------+ +---------+ +---------+
3018 // | xapp1 | | xapp2 | | submgr | | rtmgr | | e2term |
3019 // +-------+ +-------+ +---------+ +---------+ +---------+
3021 // | RESTSubReq1 | | |
3022 // |------------------------>| | |
3023 // | RESTSubResp2 | | |
3024 // |<------------------------| | |
3026 // | | | RouteCreate | |
3027 // | | |------------->| |
3028 // | | | CreateResp | |
3029 // | | |<-------------| |
3031 // | | |---------------------------->|
3032 // | | | SubResp | |
3033 // | | |<----------------------------|
3034 // | RESTNotif1 | | |
3035 // |<------------------------| | |
3037 // | | RESTSubReq2 | | |
3038 // | |------------>| | |
3039 // | | RESTSubResp2| | |
3040 // | |<------------| | |
3041 // | | | RouteUpdate | |
3042 // | | |------------->| |
3043 // | | | RouteUpdate | |
3044 // | | | status:400 | |
3045 // | | |(Bad request) | |
3046 // | | |<-------------| |
3047 // | | RESTNotif2(unsuccessful) | |
3048 // | |<------------| | |
3050 // | [SUBS INT DELETE] | |
3052 // | RESTSubDelReq1 | | |
3053 // |------------------------>| | |
3054 // | RESTSubDelResp1 | | |
3055 // |<------------------------| | |
3057 // | | | [SUBS DELETE] |
3059 //-----------------------------------------------------------------------------
3060 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
3062 //Init counter check
3063 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3064 Counter{cRestSubReqFromXapp, 2},
3065 Counter{cRestSubRespToXapp, 2},
3066 Counter{cSubReqToE2, 1},
3067 Counter{cSubRespFromE2, 1},
3068 Counter{cRestSubNotifToXapp, 1},
3069 Counter{cRestSubFailNotifToXapp, 1},
3070 Counter{cRouteCreateUpdateFail, 1},
3071 Counter{cRestSubDelReqFromXapp, 2},
3072 Counter{cSubDelReqToE2, 1},
3073 Counter{cSubDelRespFromE2, 1},
3074 Counter{cRestSubDelRespToXapp, 2},
3077 var params *teststube2ap.RESTSubsReqParams = nil
3079 // Subs create for xapp1
3080 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3082 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3084 // xapp2 ROUTE creation shall fail with 400 from rtmgr -> submgr
3085 waiter := rtmgrHttp.AllocNextEvent(false)
3086 newSubsId := mainCtrl.get_registry_next_subid(t)
3087 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3088 params.SetMeid("RAN_NAME_1")
3089 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3090 xapp.Logger.Debug("Send REST subscriber request for second subscriber : %v", restSubId2)
3091 xappConn2.ExpectRESTNotificationNok(t, restSubId2, "allFail")
3092 waiter.WaitResult(t)
3093 xappConn2.WaitRESTNotification(t, restSubId2)
3095 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3097 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3098 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
3100 mainCtrl.wait_subs_clean(t, newSubsId, 10)
3101 //Wait that subs is cleaned
3102 waitSubsCleanup(t, e2SubsId, 10)
3104 mainCtrl.VerifyCounterValues(t)
3105 mainCtrl.VerifyAllClean(t)
3108 //-----------------------------------------------------------------------------
3109 // TestRESTSubDelReqAndRouteDeleteNok
3112 // +-------+ +---------+ +---------+ +---------+
3113 // | xapp | | submgr | | rtmgr | | e2term |
3114 // +-------+ +---------+ +---------+ +---------+
3116 // | RESTSubReq | | |
3117 // |---------------->| | |
3119 // | RESTSubResp | | |
3120 // |<----------------| | |
3122 // | |---------------------------->|
3124 // | |<----------------------------|
3125 // | RESTNotif | | |
3126 // |<----------------| | |
3129 // | RESTSubDelReq | | |
3130 // |---------------->| | |
3131 // | RESTSubDelResp | | |
3132 // |<----------------| | |
3133 // | | SubSelReq | |
3134 // | |---------------------------->|
3135 // | | SubSelResp | |
3136 // | |<----------------------------|
3137 // | | RouteDelete | |
3138 // | |------------->| |
3139 // | | Routedelete | |
3140 // | | status:400 | |
3141 // | |(Bad request) | |
3142 // | |<-------------| |
3144 //-----------------------------------------------------------------------------
3146 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
3148 // Init counter check
3149 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3150 Counter{cRestSubReqFromXapp, 1},
3151 Counter{cRestSubRespToXapp, 1},
3152 Counter{cSubReqToE2, 1},
3153 Counter{cSubRespFromE2, 1},
3154 Counter{cRestSubNotifToXapp, 1},
3155 Counter{cRestSubDelReqFromXapp, 1},
3156 Counter{cRouteDeleteFail, 1},
3157 Counter{cSubDelReqToE2, 1},
3158 Counter{cSubDelRespFromE2, 1},
3159 Counter{cRestSubDelRespToXapp, 1},
3162 var params *teststube2ap.RESTSubsReqParams = nil
3165 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3167 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3169 waiter := rtmgrHttp.AllocNextEvent(false)
3170 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3171 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3172 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3173 waiter.WaitResult(t)
3175 waitSubsCleanup(t, e2SubsId, 10)
3176 mainCtrl.VerifyCounterValues(t)
3177 mainCtrl.VerifyAllClean(t)
3180 //-----------------------------------------------------------------------------
3181 // TestRESTSubMergeDelAndRouteUpdateNok
3183 // stub stub stub stub
3184 // +-------+ +-------+ +---------+ +---------+ +---------+
3185 // | xapp1 | | xapp2 | | submgr | | rtmgr | | e2term |
3186 // +-------+ +-------+ +---------+ +---------+ +---------+
3188 // | RESTSubReq1 | | |
3189 // |------------------------>| | |
3190 // | RESTSubResp2 | | |
3191 // |<------------------------| | |
3193 // | | | RouteCreate | |
3194 // | | |------------->| |
3195 // | | | CreateResp | |
3196 // | | |<-------------| |
3198 // | | |---------------------------->|
3199 // | | | SubResp | |
3200 // | | |<----------------------------|
3201 // | RESTNotif1 | | |
3202 // |<------------------------| | |
3204 // | | RESTSubReq2 | | |
3205 // | |------------>| | |
3206 // | | RESTSubResp2| | |
3207 // | |<------------| | |
3208 // | | | RouteCreate | |
3209 // | | |------------->| |
3210 // | | | CreateResp | |
3211 // | | |<-------------| |
3213 // | | |---------------------------->|
3214 // | | | SubResp | |
3215 // | | |<----------------------------|
3216 // | | RESTNotif2 | | |
3217 // | |<------------| | |
3219 // | [SUBS INT DELETE] | |
3221 // | RESTSubDelReq1 | | |
3222 // |------------------------>| | |
3223 // | RESTSubDelResp1 | | |
3224 // |<------------------------| | |
3225 // | | | SubDelReq | |
3226 // | | |---------------------------->|
3227 // | | | SubDelResp | |
3228 // | | |<----------------------------|
3229 // | | | RouteUpdate | |
3230 // | | |------------->| |
3231 // | | | RouteUpdate | |
3232 // | | | status:400 | |
3233 // | | |(Bad request) | |
3234 // | | |<-------------| |
3236 // | | RESTSubDelReq2 | |
3237 // | |------------>| | |
3238 // | | RESTSubDelResp2 | |
3239 // | |<------------| | |
3240 // | | | SubDelReq | |
3241 // | | |---------------------------->|
3242 // | | | SubdelResp | |
3243 // | | |<----------------------------|
3244 // | | | RouteDelete | |
3245 // | | |------------->| |
3246 // | | | Deleteresp | |
3247 // | | |<-------------| |
3249 //-----------------------------------------------------------------------------
3251 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
3253 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3254 Counter{cRestSubReqFromXapp, 2},
3255 Counter{cMergedSubscriptions, 1},
3256 Counter{cRestSubRespToXapp, 2},
3257 Counter{cSubReqToE2, 1},
3258 Counter{cSubRespFromE2, 1},
3259 Counter{cRestSubNotifToXapp, 2},
3260 Counter{cRestSubDelReqFromXapp, 2},
3261 Counter{cRouteDeleteUpdateFail, 1},
3262 Counter{cSubDelReqToE2, 1},
3263 Counter{cSubDelRespFromE2, 1},
3264 Counter{cRestSubDelRespToXapp, 2},
3265 Counter{cUnmergedSubscriptions, 1},
3268 var params *teststube2ap.RESTSubsReqParams = nil
3271 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3273 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3274 restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1")
3276 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
3278 //Del1, this shall fail on rtmgr side
3279 waiter := rtmgrHttp.AllocNextEvent(false)
3280 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3281 waiter.WaitResult(t)
3283 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"})
3286 deleteXapp2Subscription(t, &restSubId2)
3288 waitSubsCleanup(t, e2SubsId2, 10)
3289 mainCtrl.VerifyCounterValues(t)
3290 mainCtrl.VerifyAllClean(t)
3293 //-----------------------------------------------------------------------------
3294 // TestRESTSubReqRetransmission
3297 // +-------+ +---------+ +---------+
3298 // | xapp | | submgr | | e2term |
3299 // +-------+ +---------+ +---------+
3301 // | RESTSubReq1 | |
3302 // |---------------->| |
3304 // | RESTSubResp | |
3305 // |<----------------| |
3307 // | |------------->|
3309 // | RESTSubReq2 | |
3311 // |---------------->| |
3312 // | RESTSubResp(201)| |
3313 // |<----------------| |
3316 // | |<-------------|
3318 // |<----------------| |
3320 // | [SUBS DELETE] |
3323 //-----------------------------------------------------------------------------
3325 func TestRESTSubReqRetransmission(t *testing.T) {
3327 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3328 Counter{cRestSubReqFromXapp, 2},
3329 Counter{cRestSubRespToXapp, 2},
3330 Counter{cSubReqToE2, 1},
3331 Counter{cSubRespFromE2, 1},
3332 Counter{cRestSubNotifToXapp, 1},
3333 Counter{cRestSubDelReqFromXapp, 1},
3334 Counter{cSubDelReqToE2, 1},
3335 Counter{cSubDelRespFromE2, 1},
3336 Counter{cRestSubDelRespToXapp, 1},
3338 // Retry/duplicate will get the same way as the first request.
3339 // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
3340 // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
3343 const subReqCount int = 1
3345 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3346 restSubId := xappConn1.SendRESTSubsReq(t, params)
3348 xappConn1.SendRESTSubsReq(t, params)
3349 <-time.After(time.Second * 1)
3351 xappConn1.WaitListedRestNotifications(t, []string{restSubId})
3353 // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
3354 // the order is not significant here.
3355 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3356 e2termConn1.SendSubsResp(t, crereq, cremsg)
3358 e2SubsId := <-xappConn1.ListedRESTNotifications
3360 xapp.Logger.Debug("TEST: XAPP notification received e2SubsId=%v", e2SubsId)
3363 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3364 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3365 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3367 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsId.E2SubsId}, 10)
3369 mainCtrl.VerifyCounterValues(t)
3370 mainCtrl.VerifyAllClean(t)
3373 //-----------------------------------------------------------------------------
3375 // +-------+ +---------+ +---------+ +---------+
3376 // | xapp | | submgr | | e2term | | rtmgr |
3377 // +-------+ +---------+ +---------+ +---------+
3379 // | RESTSubReq | | |
3380 // |---------------->| | |
3381 // | RESTSubResp | | |
3382 // |<----------------| | |
3383 // | | RouteCreate | |
3384 // | |--------------------------->|
3385 // | | RouteResponse| |
3386 // | |<---------------------------| // The order of these events may vary
3388 // | |------------->| | // The order of these events may vary
3390 // | |<-------------| |
3391 // | RESTNotif1 | | |
3392 // |<----------------| | |
3393 // | RESTSubReq | | |
3394 // | [RETRANS1] | | |
3395 // |---------------->| | |
3396 // | RESTNotif1 | | |
3397 // |<----------------| | |
3398 // | RESTSubReq | | |
3399 // | [RETRANS2] | | |
3400 // |---------------->| | |
3401 // | RESTNotif1 | | |
3402 // |<----------------| | |
3403 // | RESTSubDelReq | | |
3404 // |---------------->| | |
3405 // | | SubDelReq | |
3406 // | |------------->| |
3407 // | RESTSubDelResp| | |
3408 // |<----------------| | |
3409 // | | SubDelResp | |
3410 // | |<-------------| |
3413 //-----------------------------------------------------------------------------
3415 func TestRESTSubReqRetransmissionV2(t *testing.T) {
3417 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3418 Counter{cRestSubReqFromXapp, 3},
3419 Counter{cDuplicateE2SubReq, 2},
3420 Counter{cRestSubRespToXapp, 3},
3421 Counter{cSubReqToE2, 1},
3422 Counter{cSubRespFromE2, 1},
3423 Counter{cRestSubNotifToXapp, 3},
3424 Counter{cRestSubDelReqFromXapp, 1},
3425 Counter{cSubDelReqToE2, 1},
3426 Counter{cSubDelRespFromE2, 1},
3427 Counter{cRestSubDelRespToXapp, 1},
3430 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3432 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3434 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3436 mainCtrl.WaitOngoingRequestMapEmpty()
3439 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
3441 assert.Equal(t, restSubId_resend, restSubId)
3443 mainCtrl.WaitOngoingRequestMapEmpty()
3446 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3448 assert.Equal(t, restSubId_resend2, restSubId)
3450 mainCtrl.WaitOngoingRequestMapEmpty()
3452 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3454 waitSubsCleanup(t, e2SubsId, 10)
3455 mainCtrl.VerifyCounterValues(t)
3456 mainCtrl.VerifyAllClean(t)
3459 //-----------------------------------------------------------------------------
3461 // +-------+ +---------+ +---------+ +---------+
3462 // | xapp | | submgr | | e2term | | rtmgr |
3463 // +-------+ +---------+ +---------+ +---------+
3465 // | RESTSubReq | | |
3466 // |---------------->| | |
3467 // | RESTSubResp | | |
3468 // |<----------------| | |
3469 // | | RouteCreate | |
3470 // | |--------------------------->|
3471 // | | RouteResponse| |
3472 // | |<---------------------------| // The order of these events may vary
3474 // | |------------->| | // The order of these events may vary
3476 // | |<-------------| |
3477 // | RESTNotif1 | | |
3478 // |<----------------| | |
3479 // | RESTSubReq | | |
3480 // | [RETRANS, with RESTsubsId] | |
3481 // |---------------->| | |
3482 // | RESTNotif1 | | |
3483 // |<----------------| | |
3484 // | RESTSubReq | | |
3485 // | [RETRANS, without RESTsubsId] | |
3486 // |---------------->| | |
3487 // | RESTNotif1 | | |
3488 // |<----------------| | |
3489 // | RESTSubDelReq | | |
3490 // |---------------->| | |
3491 // | | SubDelReq | |
3492 // | |------------->| |
3493 // | RESTSubDelResp| | |
3494 // |<----------------| | |
3495 // | | SubDelResp | |
3496 // | |<-------------| |
3499 //-----------------------------------------------------------------------------
3500 func TestRESTSubReqRetransmissionV3(t *testing.T) {
3502 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3503 Counter{cRestSubReqFromXapp, 3},
3504 Counter{cDuplicateE2SubReq, 2},
3505 Counter{cRestSubRespToXapp, 3},
3506 Counter{cSubReqToE2, 1},
3507 Counter{cSubRespFromE2, 1},
3508 Counter{cRestSubNotifToXapp, 3},
3509 Counter{cRestSubDelReqFromXapp, 1},
3510 Counter{cSubDelReqToE2, 1},
3511 Counter{cSubDelRespFromE2, 1},
3512 Counter{cRestSubDelRespToXapp, 1},
3515 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3517 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3519 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3521 mainCtrl.WaitOngoingRequestMapEmpty()
3523 //1.st resend with subscription ID
3524 params.SetSubscriptionID(&restSubId)
3525 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
3527 assert.Equal(t, restSubId_resend, restSubId)
3529 mainCtrl.WaitOngoingRequestMapEmpty()
3531 //2.nd resend without subscription ID (faking app restart)
3532 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3533 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3535 assert.Equal(t, restSubId_resend2, restSubId)
3537 mainCtrl.WaitOngoingRequestMapEmpty()
3539 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3541 waitSubsCleanup(t, e2SubsId, 10)
3542 mainCtrl.VerifyCounterValues(t)
3543 mainCtrl.VerifyAllClean(t)
3546 //-----------------------------------------------------------------------------
3548 // +-------+ +---------+ +---------+ +---------+
3549 // | xapp | | submgr | | e2term | | rtmgr |
3550 // +-------+ +---------+ +---------+ +---------+
3552 // | RESTSubReq | | |
3553 // |---------------->| | |
3554 // | RESTSubResp | | |
3555 // |<----------------| | |
3556 // | | RouteCreate | |
3557 // | |--------------------------->|
3558 // | | RouteResponse| |
3559 // | |<---------------------------|
3561 // | |------------->| |
3563 // | |<-------------| |
3564 // | RESTNotif1 | | |
3565 // |<----------------| | |
3566 // | RESTSubReq | | |
3567 // | [with RestSUbsId + one additional e2 subDetail]
3568 // |---------------->| | |
3569 // | RESTNotif1 | | |
3570 // | [for initial e2 subDetail] | |
3571 // |<----------------| | |
3572 // | | RouteCreate | |
3573 // | |--------------------------->|
3574 // | | RouteResponse| |
3575 // | |<---------------------------|
3577 // | |------------->| |
3579 // | |<-------------| |
3580 // | RESTNotif1 | | |
3581 // |<----------------| | |
3582 // | RESTSubReq | | |
3583 // | [with RESTsubsId initial request] |
3584 // |---------------->| | |
3585 // | RESTNotif1 | | |
3586 // |<----------------| | |
3587 // | RESTSubDelReq | | |
3588 // |---------------->| | |
3589 // | RESTSubDelResp| | |
3590 // |<----------------| | |
3591 // | | SubDelReq | |
3592 // | |------------->| |
3593 // | | SubDelResp | |
3594 // | |<-------------| |
3595 // | | SubDelReq | |
3596 // | |------------->| |
3597 // | | SubDelResp | |
3598 // | |<-------------| |
3601 //-----------------------------------------------------------------------------
3603 func TestRESTSubReqRetransmissionV4(t *testing.T) {
3605 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3606 Counter{cRestSubReqFromXapp, 3},
3607 Counter{cDuplicateE2SubReq, 2},
3608 Counter{cRestSubRespToXapp, 3},
3609 Counter{cSubReqToE2, 2},
3610 Counter{cSubRespFromE2, 2},
3611 Counter{cRestSubNotifToXapp, 4},
3612 Counter{cRestSubDelReqFromXapp, 1},
3613 Counter{cSubDelReqToE2, 2},
3614 Counter{cSubDelRespFromE2, 2},
3615 Counter{cRestSubDelRespToXapp, 1},
3618 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3620 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3622 mainCtrl.WaitOngoingRequestMapEmpty()
3624 // Send modified requst, this time with e2 subscriptions.
3625 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3626 params2.SetSubscriptionID(&restSubId)
3628 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3629 xappConn1.ExpectAnyNotification(t)
3630 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3631 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3632 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3633 assert.Equal(t, e2SubsId, e2SubsId1)
3635 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3637 xappConn1.DecrementRequestCount()
3638 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3639 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3640 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3641 assert.NotEqual(t, e2SubsId2, 0)
3643 mainCtrl.WaitOngoingRequestMapEmpty()
3645 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3646 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3647 params.SetSubscriptionID(&restSubId)
3648 xappConn1.ExpectAnyNotification(t)
3649 // Resend the original request again with only one e2 subscription (detail), this time with restsubsid
3650 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3651 assert.Equal(t, restSubId_resend, restSubId_resend2)
3653 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3654 assert.Equal(t, e2SubsId, e2SubsId1)
3656 mainCtrl.WaitOngoingRequestMapEmpty()
3658 // Delete both e2 subscriptions
3659 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3660 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3661 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3663 waitSubsCleanup(t, e2SubsId, 10)
3664 mainCtrl.VerifyCounterValues(t)
3665 mainCtrl.VerifyAllClean(t)
3668 //-----------------------------------------------------------------------------
3670 // +-------+ +---------+ +---------+ +---------+
3671 // | xapp | | submgr | | e2term | | rtmgr |
3672 // +-------+ +---------+ +---------+ +---------+
3674 // | RESTSubReq | | |
3675 // |---------------->| | |
3676 // | RESTSubResp | | |
3677 // |<----------------| | |
3678 // | | RouteCreate | |
3679 // | |--------------------------->|
3680 // | | RouteResponse| |
3681 // | |<---------------------------|
3683 // | |------------->| |
3685 // | |<-------------| |
3686 // | RESTNotif1 | | |
3687 // |<----------------| | |
3688 // | RESTSubReq | | |
3689 // | [with RestSUbsId + one additional e2 subDetail]
3690 // |---------------->| | |
3691 // | RESTNotif1 | | |
3692 // | [for initial e2 subDetail] | |
3693 // |<----------------| | |
3694 // | | RouteCreate | |
3695 // | |--------------------------->|
3696 // | | RouteResponse| |
3697 // | |<---------------------------|
3699 // | |------------->| |
3701 // | |<-------------| |
3702 // | RESTNotif1 | | |
3703 // |<----------------| | |
3704 // | RESTSubReq | | |
3705 // | [without RESTsubsId initial request] |
3706 // |---------------->| | |
3707 // | RESTNotif1 | | |
3708 // |<----------------| | |
3709 // | RESTSubDelReq | | |
3710 // |---------------->| | |
3711 // | RESTSubDelResp| | |
3712 // |<----------------| | |
3713 // | | SubDelReq | |
3714 // | |------------->| |
3715 // | | SubDelResp | |
3716 // | |<-------------| |
3717 // | | SubDelReq | |
3718 // | |------------->| |
3719 // | | SubDelResp | |
3720 // | |<-------------| |
3723 //-----------------------------------------------------------------------------
3725 func TestRESTSubReqRetransmissionV5(t *testing.T) {
3727 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3728 Counter{cRestSubReqFromXapp, 3},
3729 Counter{cDuplicateE2SubReq, 2},
3730 Counter{cRestSubRespToXapp, 3},
3731 Counter{cSubReqToE2, 2},
3732 Counter{cSubRespFromE2, 2},
3733 Counter{cRestSubNotifToXapp, 4},
3734 Counter{cRestSubDelReqFromXapp, 1},
3735 Counter{cSubDelReqToE2, 2},
3736 Counter{cSubDelRespFromE2, 2},
3737 Counter{cRestSubDelRespToXapp, 1},
3740 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3742 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3744 mainCtrl.WaitOngoingRequestMapEmpty()
3746 // Send modified request, this time with e2 subscriptions.
3747 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3748 params2.SetSubscriptionID(&restSubId)
3750 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3751 xappConn1.ExpectAnyNotification(t)
3752 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3753 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3755 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3756 assert.Equal(t, e2SubsId, e2SubsId1)
3757 // The first E2 subscription returns immediately, manually decrement expected request count for the remaining request handling
3758 xappConn1.DecrementRequestCount()
3760 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3762 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3763 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3764 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3765 assert.NotEqual(t, e2SubsId2, 0)
3767 mainCtrl.WaitOngoingRequestMapEmpty()
3769 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3770 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3771 xappConn1.ExpectAnyNotification(t)
3772 // Resend the original request again with only one e2 subscription (detail), WITHOUT restsubsid
3773 // md5sum shall find the original request
3774 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3775 assert.Equal(t, restSubId_resend, restSubId_resend2)
3777 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3778 assert.Equal(t, e2SubsId, e2SubsId1)
3780 mainCtrl.WaitOngoingRequestMapEmpty()
3782 // Delete both e2 subscriptions
3783 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3784 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3785 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3787 waitSubsCleanup(t, e2SubsId, 10)
3788 mainCtrl.VerifyCounterValues(t)
3789 mainCtrl.VerifyAllClean(t)
3792 //-----------------------------------------------------------------------------
3794 // +-------+ +---------+ +---------+ +---------+
3795 // | xapp | | submgr | | e2term | | rtmgr |
3796 // +-------+ +---------+ +---------+ +---------+
3798 // | RESTSubReq | | |
3799 // |---------------->| | |
3800 // | RESTSubResp | | |
3801 // |<----------------| | |
3802 // | | RouteCreate | |
3803 // | |--------------------------->|
3804 // | | RouteResponse| |
3805 // | |<---------------------------|
3807 // | |------------->| |
3809 // | |<-------------| |
3810 // | RESTNotif1 | | |
3811 // |<----------------| | |
3812 // | RESTSubReq | | |
3813 // | [with RestSUbsId + one additional e2 subDetail]
3814 // |---------------->| | |
3815 // | RESTNotif1 | | |
3816 // | [for initial e2 subDetail] | |
3817 // |<----------------| | |
3818 // | | RouteCreate | |
3819 // | |--------------------------->|
3820 // | | RouteResponse| |
3821 // | |<---------------------------|
3823 // | |------------->| |
3825 // | |<-------------| |
3826 // | RESTNotif1 | | |
3827 // |<----------------| | |
3828 // | RESTSubDelReq | | |
3829 // |---------------->| | |
3830 // | RESTSubDelResp| | |
3831 // |<----------------| | |
3832 // | | SubDelReq | |
3833 // | |------------->| |
3834 // | | SubDelResp | |
3835 // | |<-------------| |
3836 // | | SubDelReq | |
3837 // | |------------->| |
3838 // | | SubDelResp | |
3839 // | |<-------------| |
3840 // | RESTSubReq | | |
3841 // | [with RESTsubsId initial request] |
3842 // |---------------->| | |
3843 // | RESTSubResp | | |
3844 // |<----------------| | |
3845 // | | RouteCreate | |
3846 // | |--------------------------->|
3847 // | | RouteResponse| |
3848 // | |<---------------------------|
3850 // | |------------->| |
3852 // | |<-------------| |
3853 // | RESTNotif1 | | |
3854 // |<----------------| | |
3857 //-----------------------------------------------------------------------------
3858 func TestRESTSubReqRetransmissionV6(t *testing.T) {
3860 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3861 Counter{cRestSubReqFromXapp, 3},
3862 Counter{cDuplicateE2SubReq, 1},
3863 Counter{cRestSubRespToXapp, 3},
3864 Counter{cSubReqToE2, 3},
3865 Counter{cSubRespFromE2, 3},
3866 Counter{cRestSubNotifToXapp, 4},
3867 Counter{cRestSubDelReqFromXapp, 2},
3868 Counter{cSubDelReqToE2, 3},
3869 Counter{cSubDelRespFromE2, 3},
3870 Counter{cRestSubDelRespToXapp, 2},
3873 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3875 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3877 mainCtrl.WaitOngoingRequestMapEmpty()
3879 // Send modified requst, this time with e2 subscriptions.
3880 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3881 params2.SetSubscriptionID(&restSubId)
3883 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3884 xappConn1.ExpectAnyNotification(t)
3885 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3886 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3888 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3889 assert.Equal(t, e2SubsId, e2SubsId1)
3891 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3893 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3894 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3895 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3896 assert.NotEqual(t, e2SubsId2, 0)
3898 mainCtrl.WaitOngoingRequestMapEmpty()
3900 // Delete both e2 subscriptions
3901 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3902 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3903 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3905 waitSubsCleanup(t, e2SubsId, 10)
3907 // Resend the original request, we shall find it's previous md5sum/restsubs
3908 // but the restsubscription has been already removed. This shall trigger a
3910 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
3912 mainCtrl.WaitOngoingRequestMapEmpty()
3914 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3916 waitSubsCleanup(t, e2SubsId, 10)
3917 mainCtrl.VerifyCounterValues(t)
3918 mainCtrl.VerifyAllClean(t)
3921 //-----------------------------------------------------------------------------
3922 // TestRESTSubDelReqRetransmission
3925 // +-------+ +---------+ +---------+
3926 // | xapp | | submgr | | e2term |
3927 // +-------+ +---------+ +---------+
3930 // |---------------->| |
3932 // | RESTSubResp | |
3933 // |<----------------| |
3935 // | |------------->|
3937 // | |<-------------|
3939 // |<----------------| |
3941 // | RESTSubDelReq | |
3942 // |---------------->| |
3943 // | RESTSubDelResp | |
3944 // |<----------------| |
3946 // | |------------->|
3947 // | RESTSubDelReq | |
3948 // |---------------->| |
3949 // | RESTSubDelResp | |
3950 // |<----------------| |
3952 // | |<-------------|
3955 //-----------------------------------------------------------------------------
3957 func TestRESTSubDelReqRetransmission(t *testing.T) {
3959 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3960 Counter{cRestSubReqFromXapp, 1},
3961 Counter{cRestSubRespToXapp, 1},
3962 Counter{cSubReqToE2, 1},
3963 Counter{cSubRespFromE2, 1},
3964 Counter{cRestSubNotifToXapp, 1},
3965 Counter{cRestSubDelReqFromXapp, 2},
3966 Counter{cSubDelReqToE2, 1},
3967 Counter{cSubDelRespFromE2, 1},
3968 Counter{cRestSubDelRespToXapp, 2},
3971 var params *teststube2ap.RESTSubsReqParams = nil
3974 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3976 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3979 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3980 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3983 seqBef := mainCtrl.get_msgcounter(t)
3984 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3985 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
3988 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3990 waitSubsCleanup(t, e2SubsId, 10)
3991 mainCtrl.VerifyCounterValues(t)
3992 mainCtrl.VerifyAllClean(t)
3995 //-----------------------------------------------------------------------------
3996 // TestRESTSubReqDelReq
3999 // +-------+ +---------+ +---------+
4000 // | xapp | | submgr | | e2term |
4001 // +-------+ +---------+ +---------+
4004 // |---------------->| |
4006 // | RESTSubResp | |
4007 // |<----------------| |
4009 // | |------------->|
4010 // | RESTSubDelReq | |
4011 // |---------------->| |
4012 // | RESTSubDelResp | |
4014 // |<----------------| |
4016 // | |<-------------|
4018 // |<----------------| |
4020 // | [SUBS DELETE] |
4023 //-----------------------------------------------------------------------------
4024 func TestRESTSubReqDelReq(t *testing.T) {
4026 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4027 Counter{cRestSubReqFromXapp, 1},
4028 Counter{cRestSubRespToXapp, 1},
4029 Counter{cSubReqToE2, 1},
4030 Counter{cSubRespFromE2, 1},
4031 Counter{cRestSubNotifToXapp, 1},
4032 Counter{cRestSubDelReqFromXapp, 2},
4033 Counter{cRestSubDelFailToXapp, 1},
4034 Counter{cSubDelReqToE2, 1},
4035 Counter{cSubDelRespFromE2, 1},
4036 Counter{cRestSubDelRespToXapp, 1},
4039 const subReqCount int = 1
4042 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4043 restSubId := xappConn1.SendRESTSubsReq(t, params)
4045 // Del. This will fail as processing of the subscription
4046 // is still ongoing in submgr. Deletion is not allowed before
4047 // subscription creation has been completed.
4048 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4049 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4050 xappConn1.ExpectRESTNotification(t, restSubId)
4051 e2termConn1.SendSubsResp(t, crereq, cremsg)
4052 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4055 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4057 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4058 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4060 // Wait that subs is cleaned
4061 waitSubsCleanup(t, e2SubsId, 10)
4062 mainCtrl.VerifyCounterValues(t)
4063 mainCtrl.VerifyAllClean(t)
4066 //-----------------------------------------------------------------------------
4067 // TestRESTSubReqAndSubDelOkTwoParallel
4070 // +-------+ +-------+ +---------+ +---------+
4071 // | xapp2 | | xapp1 | | submgr | | e2term |
4072 // +-------+ +-------+ +---------+ +---------+
4074 // | | RESTSubReq1 | |
4075 // | |------------->| |
4076 // | | RESTSubResp1 | |
4077 // | |<-------------| |
4080 // | | |------------->|
4082 // | RESTSubReq2 | |
4083 // |------------------------>| |
4084 // | RESTSubResp2 | |
4085 // |<------------------------| |
4088 // | | |------------->|
4091 // | | |<-------------|
4092 // | | RESTNotif1 | |
4093 // | |<-------------| |
4096 // | | |<-------------|
4098 // |<------------------------| |
4100 // | | [SUBS 1 DELETE] |
4102 // | | [SUBS 2 DELETE] |
4105 //-----------------------------------------------------------------------------
4107 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
4109 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4110 Counter{cRestSubReqFromXapp, 2},
4111 Counter{cRestSubRespToXapp, 2},
4112 Counter{cSubReqToE2, 2},
4113 Counter{cSubRespFromE2, 2},
4114 Counter{cRestSubNotifToXapp, 2},
4115 Counter{cRestSubDelReqFromXapp, 2},
4116 Counter{cSubDelReqToE2, 2},
4117 Counter{cSubDelRespFromE2, 2},
4118 Counter{cRestSubDelRespToXapp, 2},
4122 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4123 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4124 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
4127 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4128 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4129 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
4131 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4132 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
4134 //XappConn1 receives both of the responses
4135 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4138 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4140 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
4142 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4143 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4144 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4145 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4148 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
4150 deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
4152 //Wait that subs is cleaned
4153 mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
4154 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
4156 mainCtrl.VerifyCounterValues(t)
4157 mainCtrl.VerifyAllClean(t)
4160 //-----------------------------------------------------------------------------
4161 // TestRESTSameSubsDiffRan
4162 // Same subscription to different RANs
4165 // +-------+ +---------+ +---------+
4166 // | xapp | | submgr | | e2term |
4167 // +-------+ +---------+ +---------+
4169 // | RESTSubReq(r1) | |
4170 // |---------------->| |
4171 // | RESTSubResp(r1) | |
4172 // |<----------------| |
4175 // | |------------->|
4177 // | | SubResp(r1) |
4178 // | |<-------------|
4180 // | RESTNotif(r1) | |
4181 // |<----------------| |
4183 // | RESTSubReq(r2) | |
4184 // |---------------->| |
4186 // | RESTSubResp(r2) | |
4187 // |<----------------| |
4189 // | |------------->|
4191 // | | SubResp(r2) |
4192 // | |<-------------|
4194 // | RESTNotif(r2) | |
4195 // |<----------------| |
4197 // | [SUBS r1 DELETE] |
4199 // | [SUBS r2 DELETE] |
4202 //-----------------------------------------------------------------------------
4204 func TestRESTSameSubsDiffRan(t *testing.T) {
4206 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4207 Counter{cRestSubReqFromXapp, 2},
4208 Counter{cRestSubRespToXapp, 2},
4209 Counter{cSubReqToE2, 2},
4210 Counter{cSubRespFromE2, 2},
4211 Counter{cRestSubNotifToXapp, 2},
4212 Counter{cRestSubDelReqFromXapp, 2},
4213 Counter{cSubDelReqToE2, 2},
4214 Counter{cSubDelRespFromE2, 2},
4215 Counter{cRestSubDelRespToXapp, 2},
4218 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4219 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4220 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
4222 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
4223 params.SetMeid("RAN_NAME_2")
4224 restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
4225 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
4228 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
4230 deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
4232 //Wait that subs is cleaned
4233 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4234 waitSubsCleanup(t, e2SubsId2, 10)
4236 mainCtrl.VerifyCounterValues(t)
4237 mainCtrl.VerifyAllClean(t)
4240 //-----------------------------------------------------------------------------
4241 // TestRESTSubReqRetryInSubmgr
4244 // +-------+ +---------+ +---------+
4245 // | xapp | | submgr | | e2term |
4246 // +-------+ +---------+ +---------+
4249 // |---------------->| |
4250 // | RESTSubResp | |
4251 // |<----------------| |
4253 // | |------------->|
4257 // | |------------->|
4259 // | |<-------------|
4262 // |<----------------| |
4264 // | [SUBS DELETE] |
4267 //-----------------------------------------------------------------------------
4269 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
4271 // Init counter check
4272 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4273 Counter{cRestSubReqFromXapp, 1},
4274 Counter{cRestSubRespToXapp, 1},
4275 Counter{cSubReqToE2, 1},
4276 Counter{cSubReqTimerExpiry, 1},
4277 Counter{cSubReReqToE2, 1},
4278 Counter{cSubRespFromE2, 1},
4279 Counter{cRestSubNotifToXapp, 1},
4280 Counter{cRestSubDelReqFromXapp, 1},
4281 Counter{cSubDelReqToE2, 1},
4282 Counter{cSubDelRespFromE2, 1},
4283 Counter{cRestSubDelRespToXapp, 1},
4286 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4287 restSubId := xappConn1.SendRESTSubsReq(t, params)
4289 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
4291 // Catch the first message and ignore it
4292 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4293 xapp.Logger.Debug("Ignore REST subscriber request for subscriber : %v", restSubId)
4295 // The second request is being handled normally
4296 crereq, cremsg = e2termConn1.RecvSubsReq(t)
4297 xappConn1.ExpectRESTNotification(t, restSubId)
4298 e2termConn1.SendSubsResp(t, crereq, cremsg)
4299 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4301 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4304 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
4306 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
4307 //Wait that subs is cleaned
4308 waitSubsCleanup(t, e2SubsId, 10)
4310 mainCtrl.VerifyCounterValues(t)
4311 mainCtrl.VerifyAllClean(t)
4314 //-----------------------------------------------------------------------------
4315 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
4318 // +-------+ +---------+ +---------+
4319 // | xapp | | submgr | | e2term |
4320 // +-------+ +---------+ +---------+
4323 // |---------------->| |
4325 // | RESTSubResp | |
4326 // |<----------------| |
4328 // | |------------->|
4332 // | |------------->|
4335 // | |------------->|
4339 // | |------------->|
4343 // | |<-------------|
4346 // |<----------------| |
4348 // | [SUBS DELETE] |
4351 //-----------------------------------------------------------------------------
4353 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
4355 // Init counter check
4356 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4357 Counter{cRestSubReqFromXapp, 1},
4358 Counter{cRestSubRespToXapp, 1},
4359 Counter{cSubReqToE2, 1},
4360 Counter{cSubReReqToE2, 1},
4361 Counter{cSubReqTimerExpiry, 2},
4362 Counter{cRestSubFailNotifToXapp, 1},
4363 Counter{cSubDelReqToE2, 1},
4364 Counter{cSubDelRespFromE2, 1},
4365 Counter{cRestSubDelReqFromXapp, 1},
4366 Counter{cRestSubDelRespToXapp, 1},
4369 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4370 restSubId := xappConn1.SendRESTSubsReq(t, params)
4371 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
4373 e2termConn1.RecvSubsReq(t)
4374 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
4376 e2termConn1.RecvSubsReq(t)
4377 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
4379 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4380 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
4381 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4382 xappConn1.WaitRESTNotification(t, restSubId)
4384 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4386 // Wait that subs is cleaned
4387 waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
4388 mainCtrl.VerifyCounterValues(t)
4389 mainCtrl.VerifyAllClean(t)
4392 //-----------------------------------------------------------------------------
4393 // TestREST2eTermNotRespondingToSubReq
4396 // +-------+ +---------+ +---------+
4397 // | xapp | | submgr | | e2term |
4398 // +-------+ +---------+ +---------+
4401 // |---------------->| |
4402 // | RESTSubResp | |
4403 // |<----------------| |
4405 // | |------------->|
4408 // | |------------->|
4411 // | |------------->|
4414 // | |------------->|
4415 // | RESTNotif(Unsuccessful) |
4416 // |<----------------| |
4418 // | RESTSubDelReq | |
4419 // |---------------->| |
4420 // | RESTSubDelResp | |
4421 // |<----------------| |
4424 //-----------------------------------------------------------------------------
4426 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
4428 // Init counter check
4429 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4430 Counter{cRestSubReqFromXapp, 1},
4431 Counter{cRestSubRespToXapp, 1},
4432 Counter{cSubReqToE2, 1},
4433 Counter{cSubReReqToE2, 1},
4434 Counter{cSubReqTimerExpiry, 2},
4435 Counter{cSubDelReReqToE2, 1},
4436 Counter{cRestSubFailNotifToXapp, 1},
4437 Counter{cSubDelReqToE2, 1},
4438 Counter{cSubDelReqTimerExpiry, 2},
4439 Counter{cRestSubDelReqFromXapp, 1},
4440 Counter{cRestSubDelRespToXapp, 1},
4443 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4444 restSubId := xappConn1.SendRESTSubsReq(t, params)
4445 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
4447 e2termConn1.RecvSubsReq(t)
4448 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
4450 e2termConn1.RecvSubsReq(t)
4451 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
4453 e2termConn1.RecvSubsDelReq(t)
4454 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
4456 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
4457 e2termConn1.RecvSubsDelReq(t)
4458 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
4460 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4462 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4464 waitSubsCleanup(t, e2SubsId, 10)
4465 mainCtrl.VerifyCounterValues(t)
4466 mainCtrl.VerifyAllClean(t)
4469 //-----------------------------------------------------------------------------
4470 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
4473 // +-------+ +---------+ +---------+
4474 // | xapp | | submgr | | e2term |
4475 // +-------+ +---------+ +---------+
4478 // |---------------->| |
4480 // | RESTSubResp | |
4481 // |<----------------| |
4483 // | |------------->|
4487 // | |------------->|
4490 // | |------------->|
4494 // | |------------->|
4498 // | |<-------------|
4501 // |<----------------| |
4503 // | [SUBS DELETE] |
4506 //-----------------------------------------------------------------------------
4507 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
4509 // Init counter check
4510 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4511 Counter{cRestSubReqFromXapp, 1},
4512 Counter{cRestSubRespToXapp, 1},
4513 Counter{cSubReqToE2, 1},
4514 Counter{cSubReReqToE2, 1},
4515 Counter{cSubReqTimerExpiry, 2},
4516 Counter{cRestSubFailNotifToXapp, 1},
4517 Counter{cSubDelReqToE2, 1},
4518 Counter{cSubDelReReqToE2, 1},
4519 Counter{cSubDelReqTimerExpiry, 2},
4520 Counter{cRestSubDelReqFromXapp, 1},
4521 Counter{cRestSubDelRespToXapp, 1},
4524 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4525 restSubId := xappConn1.SendRESTSubsReq(t, params)
4526 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
4528 e2termConn1.RecvSubsReq(t)
4529 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
4531 e2termConn1.RecvSubsReq(t)
4532 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
4534 e2termConn1.RecvSubsDelReq(t)
4535 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
4537 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
4538 e2termConn1.RecvSubsDelReq(t)
4539 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
4541 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4543 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4545 waitSubsCleanup(t, e2SubsId, 10)
4546 mainCtrl.VerifyCounterValues(t)
4547 mainCtrl.VerifyAllClean(t)
4550 //-----------------------------------------------------------------------------
4551 // TestRESTSubReqSubFailRespInSubmgr
4554 // +-------+ +---------+ +---------+
4555 // | xapp | | submgr | | e2term |
4556 // +-------+ +---------+ +---------+
4559 // |---------------->| |
4561 // | RESTSubResp | |
4562 // |<----------------| |
4564 // | |------------->|
4567 // | |<-------------|
4571 // |<----------------| |
4573 // | [SUBS DELETE] |
4576 //-----------------------------------------------------------------------------
4578 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
4580 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4581 Counter{cRestSubReqFromXapp, 1},
4582 Counter{cRestSubRespToXapp, 1},
4583 Counter{cSubReqToE2, 1},
4584 Counter{cSubFailFromE2, 1},
4585 Counter{cRestSubFailNotifToXapp, 1},
4586 Counter{cRestSubDelReqFromXapp, 1},
4587 Counter{cRestSubDelRespToXapp, 1},
4590 const subReqCount int = 1
4591 const e2Timeout int64 = 2
4592 const e2RetryCount int64 = 1
4593 const routingNeeded bool = true
4595 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4596 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4597 restSubId := xappConn1.SendRESTSubsReq(t, params)
4599 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4600 fparams1 := &teststube2ap.E2StubSubsFailParams{}
4601 fparams1.Set(crereq1)
4602 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
4603 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
4605 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4606 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
4608 // REST subscription sill there to be deleted
4609 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4611 // Wait that subs is cleaned
4612 waitSubsCleanup(t, e2SubsId, 10)
4614 mainCtrl.VerifyCounterValues(t)
4615 mainCtrl.VerifyAllClean(t)
4618 //-----------------------------------------------------------------------------
4619 // TestRESTSubReqPartialResp
4622 // +-------+ +---------+ +---------+
4623 // | xapp | | submgr | | e2term |
4624 // +-------+ +---------+ +---------+
4627 // |---------------->| |
4628 // | RESTSubResp | |
4629 // |<----------------| |
4631 // | |------------->|
4632 // | | SubResp | Partially accepted
4633 // | |<-------------|
4636 // |<----------------| |
4638 // | [SUBS DELETE] |
4641 //-----------------------------------------------------------------------------
4643 func TestRESTSubReqPartialResp(t *testing.T) {
4645 // Init counter check
4646 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4647 Counter{cRestSubReqFromXapp, 1},
4648 Counter{cRestSubRespToXapp, 1},
4649 Counter{cSubReqToE2, 1},
4650 Counter{cSubRespFromE2, 1},
4651 Counter{cPartialSubRespFromE2, 1},
4652 Counter{cRestSubNotifToXapp, 1},
4653 Counter{cRestSubDelReqFromXapp, 1},
4654 Counter{cSubDelReqToE2, 1},
4655 Counter{cSubDelRespFromE2, 1},
4656 Counter{cRestSubDelRespToXapp, 1},
4660 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4662 actionId := int64(2)
4663 actionType := "report"
4664 actionDefinition := []int64{5678, 1}
4665 subsequestActionType := "continue"
4666 timeToWait := "w10ms"
4667 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
4669 restSubId := xappConn1.SendRESTSubsReq(t, params)
4670 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4671 xappConn1.ExpectRESTNotification(t, restSubId)
4673 actionNotAdmittedItem := e2ap.ActionNotAdmittedItem{}
4674 actionNotAdmittedItem.ActionId = 1
4675 actionNotAdmittedItem.Cause.Content = 1
4676 actionNotAdmittedItem.Cause.Value = 8
4677 actionNotAdmittedList := e2ap.ActionNotAdmittedList{}
4678 actionNotAdmittedList.Items = append(actionNotAdmittedList.Items, actionNotAdmittedItem)
4679 e2termConn1.SendPartialSubsResp(t, crereq, cremsg, actionNotAdmittedList)
4680 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4682 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4685 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
4687 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
4688 //Wait that subs is cleaned
4689 waitSubsCleanup(t, e2SubsId, 10)
4691 mainCtrl.VerifyCounterValues(t)
4692 mainCtrl.VerifyAllClean(t)
4695 //-----------------------------------------------------------------------------
4696 // TestRESTSubDelReqRetryInSubmgr
4699 // +-------+ +---------+ +---------+
4700 // | xapp | | submgr | | e2term |
4701 // +-------+ +---------+ +---------+
4703 // | [SUBS CREATE] |
4706 // | RESTSubDelReq | |
4707 // |---------------->| |
4709 // | RESTSubDelResp | |
4710 // |<----------------| |
4712 // | |------------->|
4715 // | |------------->|
4718 // | |<-------------|
4721 //-----------------------------------------------------------------------------
4722 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
4724 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4725 Counter{cRestSubReqFromXapp, 1},
4726 Counter{cRestSubRespToXapp, 1},
4727 Counter{cSubReqToE2, 1},
4728 Counter{cSubRespFromE2, 1},
4729 Counter{cRestSubNotifToXapp, 1},
4730 Counter{cRestSubDelReqFromXapp, 1},
4731 Counter{cSubDelReqToE2, 1},
4732 Counter{cSubDelReqTimerExpiry, 1},
4733 Counter{cSubDelReReqToE2, 1},
4734 Counter{cSubDelRespFromE2, 1},
4735 Counter{cRestSubDelRespToXapp, 1},
4738 var params *teststube2ap.RESTSubsReqParams = nil
4739 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4742 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4744 // E2t: Receive 1st SubsDelReq
4745 e2termConn1.RecvSubsDelReq(t)
4747 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4748 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4749 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4751 //Wait that subs is cleaned
4752 waitSubsCleanup(t, e2SubsId, 10)
4754 mainCtrl.VerifyCounterValues(t)
4755 mainCtrl.VerifyAllClean(t)
4758 //-----------------------------------------------------------------------------
4759 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
4762 // +-------+ +---------+ +---------+
4763 // | xapp | | submgr | | e2term |
4764 // +-------+ +---------+ +---------+
4766 // | [SUBS CREATE] |
4769 // | RESTSubDelReq | |
4770 // |---------------->| |
4772 // | RESTSubDelResp | |
4773 // |<----------------| |
4775 // | |------------->|
4778 // | |------------->|
4782 //-----------------------------------------------------------------------------
4784 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
4786 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4787 Counter{cRestSubReqFromXapp, 1},
4788 Counter{cRestSubRespToXapp, 1},
4789 Counter{cSubReqToE2, 1},
4790 Counter{cSubRespFromE2, 1},
4791 Counter{cRestSubNotifToXapp, 1},
4792 Counter{cRestSubDelReqFromXapp, 1},
4793 Counter{cSubDelReqToE2, 1},
4794 Counter{cSubDelReqTimerExpiry, 1},
4795 Counter{cSubDelReReqToE2, 1},
4796 Counter{cSubDelRespFromE2, 1},
4797 Counter{cRestSubDelRespToXapp, 1},
4801 var params *teststube2ap.RESTSubsReqParams = nil
4802 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4805 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4807 // E2t: Receive 1st SubsDelReq
4808 e2termConn1.RecvSubsDelReq(t)
4810 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4811 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4812 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4814 //Wait that subs is cleaned
4815 waitSubsCleanup(t, e2SubsId, 10)
4817 mainCtrl.VerifyCounterValues(t)
4818 mainCtrl.VerifyAllClean(t)
4821 //-----------------------------------------------------------------------------
4822 // TestRESTSubDelReqSubDelFailRespInSubmgr
4825 // +-------+ +---------+ +---------+
4826 // | xapp | | submgr | | e2term |
4827 // +-------+ +---------+ +---------+
4829 // | [SUBS CREATE] |
4832 // | RESTSubDelReq | |
4833 // |---------------->| |
4835 // | RESTSubDelResp | |
4836 // |<----------------| |
4838 // | |------------->|
4841 // | |<-------------|
4844 //-----------------------------------------------------------------------------
4846 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
4848 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4849 Counter{cRestSubReqFromXapp, 1},
4850 Counter{cRestSubRespToXapp, 1},
4851 Counter{cSubReqToE2, 1},
4852 Counter{cSubRespFromE2, 1},
4853 Counter{cRestSubNotifToXapp, 1},
4854 Counter{cRestSubDelReqFromXapp, 1},
4855 Counter{cSubDelReqToE2, 1},
4856 Counter{cSubDelFailFromE2, 1},
4857 Counter{cRestSubDelRespToXapp, 1},
4861 var params *teststube2ap.RESTSubsReqParams = nil
4862 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4865 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4867 // E2t: Send receive SubsDelReq and send SubsDelFail
4868 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4869 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
4871 //Wait that subs is cleaned
4872 waitSubsCleanup(t, e2SubsId, 10)
4874 mainCtrl.VerifyCounterValues(t)
4875 mainCtrl.VerifyAllClean(t)
4878 //-----------------------------------------------------------------------------
4879 // TestRESTSubReqAndSubDelOkSameAction
4882 // +-------+ +-------+ +---------+ +---------+
4883 // | xapp2 | | xapp1 | | submgr | | e2term |
4884 // +-------+ +-------+ +---------+ +---------+
4886 // | | RESTSubReq1 | |
4887 // | |---------------->| |
4889 // | | RESTSubResp1 | |
4890 // | |<----------------| |
4893 // | | |------------->|
4895 // | | |<-------------|
4896 // | | RESTNotif1 | |
4897 // | |<----------------| |
4899 // | RESTSubReq2 | |
4900 // |------------------------------>| |
4902 // | RESTSubResp2 | |
4903 // |<------------------------------| |
4905 // | | RESTNotif2 | |
4906 // |<------------------------------| |
4908 // | | RESTSubDelReq1 | |
4909 // | |---------------->| |
4911 // | | RESTSubDelResp1 | |
4912 // | |<----------------| |
4914 // | RESTSubDelReq2 | |
4915 // |------------------------------>| |
4917 // | RESTSubDelResp2 | |
4918 // |<------------------------------| |
4920 // | | | SubDelReq2 |
4921 // | | |------------->|
4923 // | | | SubDelResp2 |
4924 // | | |<-------------|
4927 //-----------------------------------------------------------------------------
4929 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
4931 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4932 Counter{cRestSubReqFromXapp, 2},
4933 Counter{cRestSubRespToXapp, 2},
4934 Counter{cSubReqToE2, 1},
4935 Counter{cSubRespFromE2, 1},
4936 Counter{cRestSubNotifToXapp, 2},
4937 Counter{cMergedSubscriptions, 1},
4938 Counter{cUnmergedSubscriptions, 1},
4939 Counter{cRestSubDelReqFromXapp, 2},
4940 Counter{cSubDelReqToE2, 1},
4941 Counter{cSubDelRespFromE2, 1},
4942 Counter{cRestSubDelRespToXapp, 2},
4946 var params *teststube2ap.RESTSubsReqParams = nil
4949 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4950 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4953 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4954 params.SetMeid("RAN_NAME_1")
4956 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4957 xappConn2.ExpectAnyNotification(t)
4958 waiter := rtmgrHttp.AllocNextSleep(10, true)
4959 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4960 waiter.WaitResult(t)
4961 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
4962 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
4963 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
4965 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
4968 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4971 deleteXapp2Subscription(t, &restSubId2)
4973 //Wait that subs is cleaned
4974 waitSubsCleanup(t, e2SubsId2, 10)
4975 mainCtrl.VerifyCounterValues(t)
4976 mainCtrl.VerifyAllClean(t)
4979 //-----------------------------------------------------------------------------
4980 // TestSubReqAndSubDelOkSameActionParallel
4983 // +-------+ +-------+ +---------+ +---------+
4984 // | xapp2 | | xapp1 | | submgr | | e2term |
4985 // +-------+ +-------+ +---------+ +---------+
4990 // | |------------->| |
4993 // | | |------------->|
4995 // |--------------------------->| |
4997 // | | |<-------------|
4999 // | |<-------------| |
5001 // | | |------------->|
5004 // | | |<-------------|
5006 // |<---------------------------| |
5008 // | | SubDelReq 1 | |
5009 // | |------------->| |
5011 // | | SubDelResp 1 | |
5012 // | |<-------------| |
5014 // | SubDelReq 2 | |
5015 // |--------------------------->| |
5017 // | | | SubDelReq 2 |
5018 // | | |------------->|
5020 // | | | SubDelReq 2 |
5021 // | | |------------->|
5023 // | SubDelResp 2 | |
5024 // |<---------------------------| |
5026 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
5028 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5029 Counter{cRestSubReqFromXapp, 2},
5030 Counter{cRestSubRespToXapp, 2},
5031 Counter{cSubReqToE2, 2},
5032 Counter{cSubRespFromE2, 2},
5033 Counter{cRestSubNotifToXapp, 2},
5034 Counter{cRestSubDelReqFromXapp, 2},
5035 Counter{cSubDelReqToE2, 2},
5036 Counter{cSubDelRespFromE2, 2},
5037 Counter{cRestSubDelRespToXapp, 2},
5040 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5041 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
5042 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
5044 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
5045 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
5047 xappConn1.ExpectRESTNotification(t, restSubId1)
5048 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
5049 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
5051 xappConn2.ExpectRESTNotification(t, restSubId2)
5052 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
5053 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
5054 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5057 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5058 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
5059 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
5060 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
5063 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
5064 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
5065 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
5067 waitSubsCleanup(t, e2SubsId2, 10)
5068 mainCtrl.VerifyCounterValues(t)
5069 mainCtrl.VerifyAllClean(t)
5072 //-----------------------------------------------------------------------------
5073 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
5076 // +-------+ +-------+ +---------+ +---------+
5077 // | xapp2 | | xapp1 | | submgr | | e2term |
5078 // +-------+ +-------+ +---------+ +---------+
5082 // | | RESTSubReq1 | |
5083 // | |---------------->| |
5085 // | | RESTSubResp1 | |
5086 // | |<----------------| |
5088 // | | |------------->|
5089 // | RESTSubReq2 | |
5090 // |------------------------------>| |
5092 // | RESTSubResp2 | |
5093 // |<------------------------------| |
5095 // | | |------------->|
5098 // | | | SubDelReq |
5099 // | | |------------->|
5101 // | | | SubDelResp |
5102 // | | |<-------------|
5103 // | | RESTNotif1 | |
5104 // | | unsuccess | |
5105 // | |<----------------| |
5107 // | | unsuccess | |
5108 // |<------------------------------| |
5110 // | | RESTSubDelReq1 | |
5111 // | |---------------->| |
5113 // | | RESTSubDelResp1 | |
5114 // | |<----------------| |
5116 // | RESTSubDelReq2 | |
5117 // |------------------------------>| |
5119 // | RESTSubDelResp2 | |
5120 // |<------------------------------| |
5122 //-----------------------------------------------------------------------------
5124 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
5126 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5127 Counter{cRestSubReqFromXapp, 2},
5128 Counter{cMergedSubscriptions, 1},
5129 Counter{cRestSubRespToXapp, 2},
5130 Counter{cSubReqToE2, 1},
5131 Counter{cSubReqTimerExpiry, 2},
5132 Counter{cSubReReqToE2, 1},
5133 Counter{cRestSubFailNotifToXapp, 2},
5134 Counter{cUnmergedSubscriptions, 1},
5135 Counter{cRestSubDelReqFromXapp, 2},
5136 Counter{cSubDelReqToE2, 1},
5137 Counter{cSubDelRespFromE2, 1},
5138 Counter{cRestSubDelRespToXapp, 2},
5140 const subReqCount int = 1
5143 params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5144 restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
5145 crereq1, _ := e2termConn1.RecvSubsReq(t)
5148 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
5149 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
5150 params2.SetMeid("RAN_NAME_1")
5151 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
5152 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
5154 //Req1 (retransmitted)
5155 e2termConn1.RecvSubsReq(t)
5157 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
5159 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
5160 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
5162 e2SubsIdA := <-xappConn1.ListedRESTNotifications
5163 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
5164 e2SubsIdB := <-xappConn1.ListedRESTNotifications
5165 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
5168 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5171 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
5173 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
5175 //Wait that subs is cleaned
5176 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
5177 mainCtrl.VerifyCounterValues(t)
5178 mainCtrl.VerifyAllClean(t)
5181 //-----------------------------------------------------------------------------
5182 // TestRESTSubReqAndSubDelNokSameActionParallel
5185 // +-------+ +-------+ +---------+ +---------+
5186 // | xapp2 | | xapp1 | | submgr | | e2term |
5187 // +-------+ +-------+ +---------+ +---------+
5191 // | | RESTSubReq1 | |
5192 // | |---------------->| |
5194 // | | RESTSubResp1 | |
5195 // | |<----------------| |
5197 // | | |------------->|
5198 // | RESTSubReq2 | |
5199 // |------------------------------>| |
5201 // | RESTSubDelResp2 | |
5202 // |<------------------------------| |
5204 // | | |<-------------|
5206 // | | RESTNotif1 | |
5207 // | | unsuccess | |
5208 // | |<----------------| |
5210 // | | unsuccess | |
5211 // |<------------------------------| |
5213 // | | RESTSubDelReq1 | | There is no need for xApp to send delete for failed subscriptions but some xApp might do so.
5214 // | |---------------->| |
5216 // | | RESTSubDelResp1 | |
5217 // | |<----------------| |
5219 // | RESTSubDelReq2 | |
5220 // |------------------------------>| |
5222 // | RESTSubDelResp2 | |
5223 // |<------------------------------| |
5225 //-----------------------------------------------------------------------------
5227 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
5229 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5230 Counter{cRestSubReqFromXapp, 2},
5231 Counter{cMergedSubscriptions, 1},
5232 Counter{cRestSubRespToXapp, 2},
5233 Counter{cSubReqToE2, 1},
5234 Counter{cSubFailFromE2, 1},
5235 Counter{cRestSubFailNotifToXapp, 2},
5236 Counter{cUnmergedSubscriptions, 1},
5237 Counter{cRestSubDelReqFromXapp, 2},
5238 Counter{cRestSubDelRespToXapp, 2},
5241 const subReqCount int = 1
5244 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5245 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
5246 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
5249 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
5250 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
5251 params2.SetMeid("RAN_NAME_1")
5252 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
5253 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
5255 // E2t: send SubsFail (first)
5256 fparams1 := &teststube2ap.E2StubSubsFailParams{}
5257 fparams1.Set(crereq1)
5258 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
5260 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
5261 e2SubsIdA := <-xappConn1.ListedRESTNotifications
5262 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
5263 e2SubsIdB := <-xappConn1.ListedRESTNotifications
5264 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
5267 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5270 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
5272 //Wait that subs is cleaned
5273 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
5274 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
5275 mainCtrl.VerifyCounterValues(t)
5276 mainCtrl.VerifyAllClean(t)
5279 //-----------------------------------------------------------------------------
5280 // TestRESTSubReqPolicyAndSubDelOk
5283 // +-------+ +---------+ +---------+
5284 // | xapp | | submgr | | e2term |
5285 // +-------+ +---------+ +---------+
5288 // |--------------->| |
5289 // | RESTSubResp | |
5290 // |<---------------| |
5293 // | |------------->|
5296 // | |<-------------|
5299 // |<---------------| |
5302 // | RESTSubDelReq | |
5303 // |--------------->| |
5304 // | RESTSubDelResp | |
5305 // |<---------------| |
5308 // | |------------->|
5311 // | |<-------------|
5314 //-----------------------------------------------------------------------------
5316 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
5318 // Init counter check
5319 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5320 Counter{cRestSubReqFromXapp, 1},
5321 Counter{cRestSubRespToXapp, 1},
5322 Counter{cSubReqToE2, 1},
5323 Counter{cSubRespFromE2, 1},
5324 Counter{cRestSubNotifToXapp, 1},
5325 Counter{cRestSubDelReqFromXapp, 1},
5326 Counter{cSubDelReqToE2, 1},
5327 Counter{cSubDelRespFromE2, 1},
5328 Counter{cRestSubDelRespToXapp, 1},
5331 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5332 restSubId := xappConn1.SendRESTSubsReq(t, params)
5333 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
5335 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
5336 xappConn1.ExpectRESTNotification(t, restSubId)
5337 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
5338 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
5339 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
5341 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5342 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5343 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5345 // Wait that subs is cleaned
5346 waitSubsCleanup(t, e2SubsId, 10)
5347 mainCtrl.VerifyCounterValues(t)
5348 mainCtrl.VerifyAllClean(t)
5351 //-----------------------------------------------------------------------------
5352 // TestRESTSubReqPolicyChangeAndSubDelOk
5355 // +-------+ +---------+ +---------+
5356 // | xapp | | submgr | | e2term |
5357 // +-------+ +---------+ +---------+
5360 // |---------------->| |
5362 // | RESTSubResp | |
5363 // |<----------------| |
5365 // | |------------->|
5368 // | |<-------------|
5371 // |<----------------| |
5374 // |---------------->| |
5376 // | RESTSubResp | |
5377 // |<----------------| |
5379 // | |------------->|
5382 // | |<-------------|
5385 // |<----------------| |
5387 // | RESTSubDelReq | |
5388 // |---------------->| |
5391 // | |------------->|
5394 // | |<-------------|
5396 // | RESTSubDelResp | |
5397 // |<----------------| |
5399 //-----------------------------------------------------------------------------
5401 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
5403 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5404 Counter{cRestSubReqFromXapp, 2},
5405 Counter{cRestSubRespToXapp, 2},
5406 Counter{cSubReqToE2, 2},
5407 Counter{cSubRespFromE2, 2},
5408 Counter{cRestSubNotifToXapp, 2},
5409 Counter{cRestSubDelReqFromXapp, 1},
5410 Counter{cSubDelReqToE2, 1},
5411 Counter{cSubDelRespFromE2, 1},
5412 Counter{cRestSubDelRespToXapp, 1},
5415 const subReqCount int = 1
5416 const e2Timeout int64 = 1
5417 const e2RetryCount int64 = 0
5418 const routingNeeded bool = true
5421 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5422 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5423 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5426 // GetRESTSubsReqPolicyParams sets some counters on tc side.
5428 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5429 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5430 params.SetSubscriptionID(&restSubId)
5431 params.SetTimeToWait("w200ms")
5432 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
5435 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5437 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5438 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5440 // Wait that subs is cleaned
5441 waitSubsCleanup(t, e2SubsId, 10)
5442 mainCtrl.VerifyCounterValues(t)
5443 mainCtrl.VerifyAllClean(t)
5446 //-----------------------------------------------------------------------------
5447 // TestRESTSubReqPolicyChangeNOk
5450 // +-------+ +---------+ +---------+
5451 // | xapp | | submgr | | e2term |
5452 // +-------+ +---------+ +---------+
5455 // |---------------->| |
5457 // | RESTSubResp | |
5458 // |<----------------| |
5460 // | |------------->|
5463 // | |<-------------|
5466 // |<----------------| |
5469 // |---------------->| |
5471 // | RESTSubUpdateFail(400 Bad request)
5473 // | RESTSubDelReq | |
5474 // |---------------->| |
5477 // | |------------->|
5480 // | |<-------------|
5482 // | RESTSubDelResp | |
5483 // |<----------------| |
5485 //-----------------------------------------------------------------------------
5487 func TestRESTSubReqPolicyChangeNOk(t *testing.T) {
5489 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5490 Counter{cRestSubReqFromXapp, 2},
5491 Counter{cRestSubRespToXapp, 1},
5492 Counter{cSubReqToE2, 1},
5493 Counter{cSubRespFromE2, 1},
5494 Counter{cRestSubNotifToXapp, 1},
5495 Counter{cRestSubFailToXapp, 1},
5496 Counter{cRestSubDelReqFromXapp, 1},
5497 Counter{cSubDelReqToE2, 1},
5498 Counter{cSubDelRespFromE2, 1},
5499 Counter{cRestSubDelRespToXapp, 1},
5503 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5504 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5507 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5509 restSubIdUpd := strings.ToUpper(restSubId) // This makes RESTSubReq to fail
5510 params.SetSubscriptionID(&restSubIdUpd)
5511 params.SetTimeToWait("w200ms")
5513 restSubId2 := xappConn1.SendRESTSubsReq(t, params)
5514 assert.Equal(t, restSubId2, "")
5517 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5519 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5520 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5522 // Wait that subs is cleaned
5523 waitSubsCleanup(t, e2SubsId, 10)
5524 mainCtrl.VerifyCounterValues(t)
5525 mainCtrl.VerifyAllClean(t)
5528 //-----------------------------------------------------------------------------
5529 // TestRESTSubReqAndSubDelOkTwoE2termParallel
5532 // +-------+ +---------+ +---------+ +---------+
5533 // | xapp | | submgr | | e2term1 | | e2term2 |
5534 // +-------+ +---------+ +---------+ +---------+
5538 // | RESTSubReq1 | | |
5539 // |---------------->| | |
5541 // | RESTSubResp1 | | |
5542 // |<----------------| | |
5544 // | |------------->| |
5546 // | RESTSubReq2 | | |
5547 // |---------------->| | |
5549 // | RESTSubResp2 | | |
5550 // |<----------------| | |
5552 // | |---------------------------->|
5555 // | |<-------------| |
5556 // | RESTNotif1 | | |
5557 // |<----------------| | |
5559 // | |<----------------------------|
5560 // | RESTNotif2 | | |
5561 // |<----------------| | |
5563 // | [SUBS 1 DELETE] | |
5565 // | [SUBS 2 DELETE] | |
5568 //-----------------------------------------------------------------------------
5570 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
5572 // Init counter check
5573 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5574 Counter{cRestSubReqFromXapp, 2},
5575 Counter{cRestSubRespToXapp, 2},
5576 Counter{cSubReqToE2, 2},
5577 Counter{cSubRespFromE2, 2},
5578 Counter{cRestSubNotifToXapp, 2},
5579 Counter{cRestSubDelReqFromXapp, 2},
5580 Counter{cSubDelReqToE2, 2},
5581 Counter{cSubDelRespFromE2, 2},
5582 Counter{cRestSubDelRespToXapp, 2},
5585 const subReqCount int = 1
5588 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5589 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
5590 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
5593 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5594 params.SetMeid("RAN_NAME_11")
5595 // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
5596 // would not work as notification would not be received
5597 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5598 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
5601 xappConn1.ExpectRESTNotification(t, restSubId1)
5602 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
5603 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
5604 xapp.Logger.Debug("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
5607 xappConn2.ExpectRESTNotification(t, restSubId2)
5608 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
5609 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5610 xapp.Logger.Debug("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
5613 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5614 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
5615 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
5617 // Wait that subs is cleaned
5618 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
5621 xappConn1.SendRESTSubsDelReq(t, &restSubId2)
5622 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
5623 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
5625 // Wait that subs is cleaned
5626 waitSubsCleanup(t, e2SubsId2, 10)
5628 mainCtrl.VerifyCounterValues(t)
5629 mainCtrl.VerifyAllClean(t)
5632 //-----------------------------------------------------------------------------
5633 // TestRESTSubReqInsertAndSubDelOk
5636 // +-------+ +---------+ +---------+
5637 // | xapp | | submgr | | e2term |
5638 // +-------+ +---------+ +---------+
5641 // |---------------->| |
5643 // | RESTSubResp | |
5644 // |<----------------| |
5647 // | |------------->|
5650 // | |<-------------|
5652 // |<----------------| |
5655 // | RESTSubDelReq | |
5656 // |---------------->| |
5659 // | |------------->|
5662 // | |<-------------|
5664 // | RESTSubDelResp| |
5665 // |<----------------| |
5667 //-----------------------------------------------------------------------------
5669 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
5671 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5672 Counter{cRestSubReqFromXapp, 1},
5673 Counter{cRestSubRespToXapp, 1},
5674 Counter{cSubReqToE2, 1},
5675 Counter{cSubRespFromE2, 1},
5676 Counter{cRestSubNotifToXapp, 1},
5677 Counter{cRestSubDelReqFromXapp, 1},
5678 Counter{cSubDelReqToE2, 1},
5679 Counter{cSubDelRespFromE2, 1},
5680 Counter{cRestSubDelRespToXapp, 1},
5683 const subReqCount int = 1
5685 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5686 params.SetSubActionTypes("insert")
5689 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5692 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5694 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5695 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5697 // Wait that subs is cleaned
5698 waitSubsCleanup(t, e2SubsId, 10)
5699 mainCtrl.VerifyCounterValues(t)
5700 mainCtrl.VerifyAllClean(t)
5703 //-----------------------------------------------------------------------------
5704 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
5707 // +-------+ +---------+ +---------+
5708 // | xapp | | submgr | | e2term |
5709 // +-------+ +---------+ +---------+
5712 // |------------->| |
5714 // | RESTSubResp | |
5715 // |<-------------| |
5717 // | |------------->|
5722 // | Submgr restart |
5726 // | |------------->|
5729 // | |<-------------|
5733 // |<-------------| |
5735 // | RESTSubDelReq| |
5736 // |------------->| |
5738 // |RESTSubDelResp| |
5739 // |<-------------| |
5741 //-----------------------------------------------------------------------------
5743 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
5745 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5746 Counter{cRestSubReqFromXapp, 1},
5747 Counter{cRestSubRespToXapp, 1},
5748 Counter{cSubReqToE2, 1},
5749 Counter{cSubDelReqFromXapp, 1},
5750 Counter{cSubDelReqToE2, 1},
5751 Counter{cSubDelRespFromE2, 1},
5752 Counter{cRestSubDelReqFromXapp, 1},
5753 Counter{cRestSubDelRespToXapp, 1},
5756 const subReqCount int = 1
5758 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5761 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
5762 restSubId := xappConn1.SendRESTSubsReq(t, params)
5763 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5765 e2termConn1.RecvSubsReq(t)
5767 mainCtrl.SetResetTestFlag(t, false)
5769 mainCtrl.SimulateRestart(t)
5770 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5772 // Deleletion of uncompleted subscription
5773 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5774 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5777 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5779 xappConn1.TestMsgChanEmpty(t)
5780 e2termConn1.TestMsgChanEmpty(t)
5781 mainCtrl.wait_registry_empty(t, 10)
5783 mainCtrl.VerifyCounterValues(t)
5784 mainCtrl.VerifyAllClean(t)
5787 //-----------------------------------------------------------------------------
5788 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
5791 // +-------+ +---------+ +---------+
5792 // | xapp | | submgr | | e2term |
5793 // +-------+ +---------+ +---------+
5796 // |---------------->| |
5798 // | RESTSubResp | |
5799 // |<----------------| |
5801 // | |------------->|
5804 // | |<-------------|
5807 // |<----------------| |
5810 // | Submgr restart |
5812 // | RESTSubDelReq | |
5813 // |---------------->| |
5816 // | |------------->|
5819 // | |<-------------|
5821 // | RESTSubDelResp | |
5822 // |<----------------| |
5824 //-----------------------------------------------------------------------------
5826 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
5828 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5829 Counter{cRestSubReqFromXapp, 1},
5830 Counter{cRestSubRespToXapp, 1},
5831 Counter{cSubReqToE2, 1},
5832 Counter{cSubRespFromE2, 1},
5833 Counter{cRestSubNotifToXapp, 1},
5834 Counter{cRestSubDelReqFromXapp, 1},
5835 Counter{cSubDelReqToE2, 1},
5836 Counter{cSubDelRespFromE2, 1},
5837 Counter{cRestSubDelRespToXapp, 1},
5840 // Create subscription
5841 var params *teststube2ap.RESTSubsReqParams = nil
5842 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5843 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5845 // Check subscription
5846 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5848 mainCtrl.SimulateRestart(t)
5849 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5851 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5852 // That needs to be completed before successful subscription query is possible
5853 <-time.After(time.Second * 1)
5855 // Check subscription
5856 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5858 // Delete subscription
5859 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
5861 //Wait that subs is cleaned
5862 waitSubsCleanup(t, e2SubsId, 10)
5864 mainCtrl.VerifyCounterValues(t)
5865 mainCtrl.VerifyAllClean(t)
5868 //-----------------------------------------------------------------------------
5869 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
5872 // +-------+ +-------+ +---------+ +---------+
5873 // | xapp2 | | xapp1 | | submgr | | e2term |
5874 // +-------+ +-------+ +---------+ +---------+
5876 // | | RESTSubReq1 | |
5877 // | |---------------->| |
5879 // | | RESTSubResp1 | |
5880 // | |<----------------| |
5883 // | | |------------->|
5885 // | | |<-------------|
5886 // | | RESTNotif1 | |
5887 // | |<----------------| |
5889 // | RESTSubReq2 | |
5890 // |------------------------------>| |
5892 // | RESTSubResp2 | |
5893 // |<------------------------------| |
5895 // | | RESTNotif2 | |
5896 // |<------------------------------| |
5898 // | | Submgr restart |
5900 // | | RESTSubDelReq1 | |
5901 // | |---------------->| |
5903 // | | RESTSubDelResp1 | |
5904 // | |<----------------| |
5906 // | | Submgr restart |
5908 // | RESTSubDelReq2 | |
5909 // |------------------------------>| |
5911 // | RESTSubDelResp2 | |
5912 // |<------------------------------| |
5914 // | | | SubDelReq2 |
5915 // | | |------------->|
5917 // | | | SubDelResp2 |
5918 // | | |<-------------|
5921 //-----------------------------------------------------------------------------
5922 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
5924 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5925 Counter{cRestSubReqFromXapp, 2},
5926 Counter{cRestSubRespToXapp, 2},
5927 Counter{cSubReqToE2, 1},
5928 Counter{cSubRespFromE2, 1},
5929 Counter{cRestSubNotifToXapp, 2},
5930 Counter{cMergedSubscriptions, 1},
5931 Counter{cUnmergedSubscriptions, 1},
5932 Counter{cRestSubDelReqFromXapp, 2},
5933 Counter{cSubDelReqToE2, 1},
5934 Counter{cSubDelRespFromE2, 1},
5935 Counter{cRestSubDelRespToXapp, 2},
5938 // Create subscription 1
5939 var params *teststube2ap.RESTSubsReqParams = nil
5940 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5941 xapp.Logger.Debug("Send REST subscriber request for subscriber 1 : %v", restSubId1)
5943 // Create subscription 2 with same action
5944 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5945 params.SetMeid("RAN_NAME_1")
5946 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
5947 xappConn2.ExpectAnyNotification(t)
5948 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5949 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5950 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
5951 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
5953 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
5955 mainCtrl.SimulateRestart(t)
5956 xapp.Logger.Debug("mainCtrl.SimulateRestart done 1")
5958 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5959 // That needs to be completed before successful subscription delete is possible
5960 <-time.After(time.Second * 1)
5962 // Delete subscription 1, and wait until it has removed the first endpoint
5963 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5964 mainCtrl.WaitRESTSubscriptionDelete(restSubId1)
5965 // Above wait does not work correctly anymore as this delay makes this test case work
5967 mainCtrl.SimulateRestart(t)
5968 xapp.Logger.Debug("mainCtrl.SimulateRestart done 2")
5970 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5971 // That needs to be completed before successful subscription query is possible
5972 <-time.After(time.Second * 1)
5974 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
5976 // Delete subscription 2
5977 deleteXapp2Subscription(t, &restSubId2)
5979 //Wait that subs is cleaned
5980 waitSubsCleanup(t, e2SubsId2, 10)
5982 mainCtrl.VerifyCounterValues(t)
5983 mainCtrl.VerifyAllClean(t)
5986 //-----------------------------------------------------------------------------
5987 // TestRESTReportSubReqAndSubDelOk
5990 // +-------+ +---------+ +---------+
5991 // | xapp | | submgr | | e2term |
5992 // +-------+ +---------+ +---------+
5995 // |---------------->| |
5997 // | RESTSubResp | |
5998 // |<----------------| |
6001 // | |------------->|
6004 // | |<-------------|
6006 // |<----------------| |
6007 // | | SubReq | // Only one request sent in the teat case
6008 // | |------------->|
6011 // | |<-------------|
6013 // |<----------------| |
6017 // | RESTSubDelReq | |
6018 // |---------------->| |
6020 // | RESTSubDelResp| |
6021 // |<----------------| |
6023 // | |------------->|
6026 // | |<-------------|
6029 //-----------------------------------------------------------------------------
6031 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
6032 const subReqCount int = 1
6034 RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
6037 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
6038 xapp.Logger.Debug("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
6040 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6041 Counter{cRestSubReqFromXapp, 1},
6042 Counter{cRestSubRespToXapp, 1},
6043 Counter{cSubReqToE2, uint64(subReqCount)},
6044 Counter{cSubRespFromE2, uint64(subReqCount)},
6045 Counter{cRestSubNotifToXapp, 1},
6046 Counter{cRestSubDelReqFromXapp, 1},
6047 Counter{cRestSubDelRespToXapp, 1},
6048 Counter{cSubDelReqToE2, uint64(subReqCount)},
6049 Counter{cSubDelRespFromE2, uint64(subReqCount)},
6053 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6054 restSubId := xappConn1.SendRESTSubsReq(t, params)
6056 var e2SubsId []uint32
6057 for i := 0; i < subReqCount; i++ {
6058 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6059 xappConn1.ExpectRESTNotification(t, restSubId)
6061 e2termConn1.SendSubsResp(t, crereq, cremsg)
6062 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6063 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6064 e2SubsId = append(e2SubsId, instanceId)
6065 resp, _ := xapp.Subscription.QuerySubscriptions()
6066 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
6067 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
6068 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
6073 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6075 for i := 0; i < subReqCount; i++ {
6076 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6077 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6080 // Wait that subs is cleaned
6081 for i := 0; i < subReqCount; i++ {
6082 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
6085 xappConn1.TestMsgChanEmpty(t)
6086 e2termConn1.TestMsgChanEmpty(t)
6087 mainCtrl.wait_registry_empty(t, 10)
6088 mainCtrl.VerifyAllClean(t)
6089 mainCtrl.VerifyCounterValues(t)
6092 //-----------------------------------------------------------------------------
6093 // TestRESTTwoPolicySubReqAndSubDelOk
6096 // +-------+ +---------+ +---------+
6097 // | xapp | | submgr | | e2term |
6098 // +-------+ +---------+ +---------+
6101 // |---------------->| |
6103 // | RESTSubResp | |
6104 // |<----------------| |
6107 // | |------------->|
6110 // | |<-------------|
6112 // |<----------------| |
6114 // | |------------->|
6117 // | |<-------------|
6119 // |<----------------| |
6121 // | RESTSubDelReq | |
6122 // |---------------->| |
6124 // | RESTSubDelResp| |
6125 // |<----------------| |
6127 // | |------------->|
6130 // | |<-------------|
6133 // | |------------->|
6136 // | |<-------------|
6139 //-----------------------------------------------------------------------------
6141 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
6143 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6144 Counter{cRestSubReqFromXapp, 1},
6145 Counter{cRestSubRespToXapp, 1},
6146 Counter{cSubReqToE2, 2},
6147 Counter{cSubRespFromE2, 2},
6148 Counter{cRestSubNotifToXapp, 2},
6149 Counter{cRestSubDelReqFromXapp, 1},
6150 Counter{cSubDelReqToE2, 2},
6151 Counter{cSubDelRespFromE2, 2},
6152 Counter{cRestSubDelRespToXapp, 1},
6155 const subReqCount int = 2
6158 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6159 restSubId := xappConn1.SendRESTSubsReq(t, params)
6160 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
6162 assert.Equal(t, len(e2SubsIds), 2)
6165 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6166 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
6168 xappConn1.TestMsgChanEmpty(t)
6169 e2termConn1.TestMsgChanEmpty(t)
6170 mainCtrl.wait_registry_empty(t, 10)
6172 mainCtrl.VerifyCounterValues(t)
6173 mainCtrl.VerifyAllClean(t)
6176 //-----------------------------------------------------------------------------
6177 // TestRESTPolicySubReqAndSubDelOk19E2Subs
6180 // +-------+ +---------+ +---------+
6181 // | xapp | | submgr | | e2term |
6182 // +-------+ +---------+ +---------+
6185 // |---------------->| |
6187 // | RESTSubResp | |
6188 // |<----------------| |
6191 // | |------------->|
6192 // | | | E2 subscription x 19
6194 // | |<-------------|
6196 // |<----------------| |
6198 // | RESTSubDelReq | |
6199 // |---------------->| |
6201 // | RESTSubDelResp| |
6202 // |<----------------| |
6203 // | | SubDelReq | ------
6204 // | |------------->|
6205 // | | | E2 subscription delete x 19
6207 // | |<-------------|
6211 //-----------------------------------------------------------------------------
6213 func TestRESTPolicySubReqAndSubDelOk19E2Subs(t *testing.T) {
6215 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6216 Counter{cRestSubReqFromXapp, 1},
6217 Counter{cRestSubRespToXapp, 1},
6218 Counter{cSubReqToE2, 19},
6219 Counter{cSubRespFromE2, 19},
6220 Counter{cRestSubNotifToXapp, 19},
6221 Counter{cRestSubDelReqFromXapp, 1},
6222 Counter{cSubDelReqToE2, 19},
6223 Counter{cSubDelRespFromE2, 19},
6224 Counter{cRestSubDelRespToXapp, 1},
6227 const subReqCount int = 19
6229 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6230 restSubId := xappConn1.SendRESTSubsReq(t, params)
6231 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
6233 assert.Equal(t, len(e2SubsIds), 19)
6235 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6236 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
6238 xappConn1.TestMsgChanEmpty(t)
6239 e2termConn1.TestMsgChanEmpty(t)
6240 mainCtrl.wait_registry_empty(t, 10)
6242 mainCtrl.VerifyCounterValues(t)
6243 mainCtrl.VerifyAllClean(t)
6246 //-----------------------------------------------------------------------------
6247 // TestRESTTwoPolicySubReqAndSubDelOk
6250 // +-------+ +---------+ +---------+
6251 // | xapp | | submgr | | e2term |
6252 // +-------+ +---------+ +---------+
6255 // |---------------->| |
6257 // | RESTSubResp | |
6258 // |<----------------| |
6261 // | |------------->|
6264 // | |<-------------|
6266 // |<----------------| |
6268 // | |------------->|
6271 // | |<-------------|
6273 // |<----------------| |
6275 // | RESTSubDelReq | |
6276 // |---------------->| |
6278 // | RESTSubDelResp| |
6279 // |<----------------| |
6281 // | |------------->|
6284 // | |<-------------|
6287 // | |------------->|
6290 // | |<-------------|
6293 //-----------------------------------------------------------------------------
6295 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
6299 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6300 Counter{cRestSubReqFromXapp, 1},
6301 Counter{cRestSubRespToXapp, 1},
6302 Counter{cSubReqToE2, uint64(subReqCount)},
6303 Counter{cSubRespFromE2, uint64(subReqCount)},
6304 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
6305 Counter{cRestSubDelReqFromXapp, 1},
6306 Counter{cSubDelReqToE2, uint64(subReqCount)},
6307 Counter{cSubDelRespFromE2, uint64(subReqCount)},
6308 Counter{cRestSubDelRespToXapp, 1},
6312 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6313 restSubId := xappConn1.SendRESTSubsReq(t, params)
6314 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
6316 assert.Equal(t, len(e2SubsIds), subReqCount)
6319 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6320 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
6322 xappConn1.TestMsgChanEmpty(t)
6323 e2termConn1.TestMsgChanEmpty(t)
6324 mainCtrl.wait_registry_empty(t, 10)
6326 mainCtrl.VerifyCounterValues(t)
6327 mainCtrl.VerifyAllClean(t)
6330 //-----------------------------------------------------------------------------
6331 // TestRESTTwoReportSubReqAndSubDelOkNoActParams
6334 // +-------+ +---------+ +---------+
6335 // | xapp | | submgr | | e2term |
6336 // +-------+ +---------+ +---------+
6339 // |---------------->| |
6341 // | RESTSubResp | |
6342 // |<----------------| |
6345 // | |------------->|
6348 // | |<-------------|
6350 // |<----------------| |
6352 // | |------------->|
6355 // | |<-------------|
6357 // |<----------------| |
6359 // | RESTSubDelReq | |
6360 // |---------------->| |
6362 // | RESTSubDelResp| |
6363 // |<----------------| |
6365 // | |------------->|
6368 // | |<-------------|
6371 // | |------------->|
6374 // | |<-------------|
6377 //-----------------------------------------------------------------------------
6379 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
6383 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6384 Counter{cRestSubReqFromXapp, 1},
6385 Counter{cRestSubRespToXapp, 1},
6386 Counter{cSubReqToE2, uint64(subReqCount)},
6387 Counter{cSubRespFromE2, uint64(subReqCount)},
6388 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
6389 Counter{cRestSubDelReqFromXapp, 1},
6390 Counter{cSubDelReqToE2, uint64(subReqCount)},
6391 Counter{cSubDelRespFromE2, uint64(subReqCount)},
6392 Counter{cRestSubDelRespToXapp, 1},
6396 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6397 restSubId := xappConn1.SendRESTSubsReq(t, params)
6398 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
6400 assert.Equal(t, len(e2SubsIds), subReqCount)
6403 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6404 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
6406 xappConn1.TestMsgChanEmpty(t)
6407 e2termConn1.TestMsgChanEmpty(t)
6408 mainCtrl.wait_registry_empty(t, 10)
6410 mainCtrl.VerifyCounterValues(t)
6411 mainCtrl.VerifyAllClean(t)
6414 //-----------------------------------------------------------------------------
6415 // TestRESTReportSubReqAndSubDelOk19E2Subs
6418 // +-------+ +---------+ +---------+
6419 // | xapp | | submgr | | e2term |
6420 // +-------+ +---------+ +---------+
6423 // |---------------->| |
6425 // | RESTSubResp | |
6426 // |<----------------| |
6429 // | |------------->|
6430 // | | | E2 subscription x 19
6432 // | |<-------------|
6434 // |<----------------| |
6436 // | RESTSubDelReq | |
6437 // |---------------->| |
6439 // | RESTSubDelResp| |
6440 // |<----------------| |
6441 // | | SubDelReq | ------
6442 // | |------------->|
6443 // | | | E2 subscription delete x 19
6445 // | |<-------------|
6449 //-----------------------------------------------------------------------------
6451 func TestRESTReportSubReqAndSubDelOk19E2Subs(t *testing.T) {
6455 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6456 Counter{cRestSubReqFromXapp, 1},
6457 Counter{cRestSubRespToXapp, 1},
6458 Counter{cSubReqToE2, uint64(subReqCount)},
6459 Counter{cSubRespFromE2, uint64(subReqCount)},
6460 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
6461 Counter{cRestSubDelReqFromXapp, 1},
6462 Counter{cSubDelReqToE2, uint64(subReqCount)},
6463 Counter{cSubDelRespFromE2, uint64(subReqCount)},
6464 Counter{cRestSubDelRespToXapp, 1},
6468 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6469 restSubId := xappConn1.SendRESTSubsReq(t, params)
6470 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
6472 assert.Equal(t, len(e2SubsIds), subReqCount)
6475 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6476 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
6478 xappConn1.TestMsgChanEmpty(t)
6479 e2termConn1.TestMsgChanEmpty(t)
6480 mainCtrl.wait_registry_empty(t, 10)
6482 mainCtrl.VerifyCounterValues(t)
6483 mainCtrl.VerifyAllClean(t)
6486 //-----------------------------------------------------------------------------
6487 // TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen
6490 // +-------+ +-------+ +---------+ +---------+
6491 // | xapp2 | | xapp1 | | submgr | | e2term |
6492 // +-------+ +-------+ +---------+ +---------+
6494 // | | RESTSubReq1 | |
6495 // | |------------->| |
6496 // | | RESTSubResp1 | |
6497 // | |<-------------| |
6500 // | | |------------->|
6502 // | RESTSubReq2 | |
6503 // |------------------------>| |
6504 // | RESTSubResp2 | |
6505 // |<------------------------| |
6508 // | | |------------->|
6511 // | | |<-------------|
6512 // | | RESTNotif1 | |
6513 // | |<-------------| |
6516 // | | |<-------------|
6518 // |<------------------------| |
6520 // | | [SUBS 1 DELETE] |
6522 // | | [SUBS 2 DELETE] |
6525 //-----------------------------------------------------------------------------
6527 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
6529 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6530 Counter{cRestSubReqFromXapp, 2},
6531 Counter{cRestSubRespToXapp, 2},
6532 Counter{cSubReqToE2, 2},
6533 Counter{cSubRespFromE2, 2},
6534 Counter{cRestSubNotifToXapp, 2},
6535 Counter{cRestSubDelReqFromXapp, 2},
6536 Counter{cSubDelReqToE2, 2},
6537 Counter{cSubDelRespFromE2, 2},
6538 Counter{cRestSubDelRespToXapp, 2},
6542 var params *teststube2ap.RESTSubsReqParams = nil
6545 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
6546 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
6548 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
6551 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
6552 params.SetMeid("RAN_NAME_1")
6553 eventTriggerDefinition := []int64{1234, 1}
6554 params.SetSubEventTriggerDefinition(eventTriggerDefinition)
6556 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
6557 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
6558 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6559 xappConn2.ExpectRESTNotification(t, restSubId2)
6560 e2termConn1.SendSubsResp(t, crereq, cremsg)
6561 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
6563 deleteXapp1Subscription(t, &restSubId1)
6564 deleteXapp2Subscription(t, &restSubId2)
6566 waitSubsCleanup(t, e2SubsId1, 10)
6567 waitSubsCleanup(t, e2SubsId2, 10)
6569 mainCtrl.VerifyCounterValues(t)
6570 mainCtrl.VerifyAllClean(t)
6573 //-----------------------------------------------------------------------------
6574 // TestRESTSubReqReportSameActionDiffActionListLen
6577 // +-------+ +-------+ +---------+ +---------+
6578 // | xapp2 | | xapp1 | | submgr | | e2term |
6579 // +-------+ +-------+ +---------+ +---------+
6581 // | | RESTSubReq1 | |
6582 // | |------------->| |
6583 // | | RESTSubResp1 | |
6584 // | |<-------------| |
6587 // | | |------------->|
6589 // | RESTSubReq2 | |
6590 // |------------------------>| |
6591 // | RESTSubResp2 | |
6592 // |<------------------------| |
6595 // | | |------------->|
6598 // | | |<-------------|
6599 // | | RESTNotif1 | |
6600 // | |<-------------| |
6603 // | | |<-------------|
6605 // |<------------------------| |
6607 // | | [SUBS 1 DELETE] |
6609 // | | [SUBS 2 DELETE] |
6612 //-----------------------------------------------------------------------------
6614 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
6616 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6617 Counter{cRestSubReqFromXapp, 2},
6618 Counter{cRestSubRespToXapp, 2},
6619 Counter{cSubReqToE2, 2},
6620 Counter{cSubRespFromE2, 2},
6621 Counter{cRestSubNotifToXapp, 2},
6622 Counter{cRestSubDelReqFromXapp, 2},
6623 Counter{cSubDelReqToE2, 2},
6624 Counter{cSubDelRespFromE2, 2},
6625 Counter{cRestSubDelRespToXapp, 2},
6629 var params *teststube2ap.RESTSubsReqParams = nil
6632 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
6633 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
6635 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
6638 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
6639 params.SetMeid("RAN_NAME_1")
6641 actionId := int64(1)
6642 actionType := "report"
6643 actionDefinition := []int64{5678, 1}
6644 subsequestActionType := "continue"
6645 timeToWait := "w10ms"
6646 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
6648 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
6649 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
6650 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6651 xappConn2.ExpectRESTNotification(t, restSubId2)
6652 e2termConn1.SendSubsResp(t, crereq, cremsg)
6653 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
6655 deleteXapp1Subscription(t, &restSubId1)
6656 deleteXapp2Subscription(t, &restSubId2)
6658 waitSubsCleanup(t, e2SubsId1, 10)
6659 waitSubsCleanup(t, e2SubsId2, 10)
6661 mainCtrl.VerifyCounterValues(t)
6662 mainCtrl.VerifyAllClean(t)
6665 //-----------------------------------------------------------------------------
6666 // TestRESTSubReqReportSameActionDiffActionID
6669 // +-------+ +-------+ +---------+ +---------+
6670 // | xapp2 | | xapp1 | | submgr | | e2term |
6671 // +-------+ +-------+ +---------+ +---------+
6673 // | | RESTSubReq1 | |
6674 // | |------------->| |
6675 // | | RESTSubResp1 | |
6676 // | |<-------------| |
6679 // | | |------------->|
6681 // | RESTSubReq2 | |
6682 // |------------------------>| |
6683 // | RESTSubResp2 | |
6684 // |<------------------------| |
6687 // | | |------------->|
6690 // | | |<-------------|
6691 // | | RESTNotif1 | |
6692 // | |<-------------| |
6695 // | | |<-------------|
6697 // |<------------------------| |
6699 // | | [SUBS 1 DELETE] |
6701 // | | [SUBS 2 DELETE] |
6704 //-----------------------------------------------------------------------------
6706 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
6708 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6709 Counter{cRestSubReqFromXapp, 2},
6710 Counter{cRestSubRespToXapp, 2},
6711 Counter{cSubReqToE2, 2},
6712 Counter{cSubRespFromE2, 2},
6713 Counter{cRestSubNotifToXapp, 2},
6714 Counter{cRestSubDelReqFromXapp, 2},
6715 Counter{cSubDelReqToE2, 2},
6716 Counter{cSubDelRespFromE2, 2},
6717 Counter{cRestSubDelRespToXapp, 2},
6721 var params *teststube2ap.RESTSubsReqParams = nil
6724 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
6725 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
6727 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
6730 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
6731 params.SetMeid("RAN_NAME_1")
6732 params.SetSubActionIDs(int64(2))
6734 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
6735 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
6736 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6737 xappConn2.ExpectRESTNotification(t, restSubId2)
6738 e2termConn1.SendSubsResp(t, crereq, cremsg)
6739 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
6741 deleteXapp1Subscription(t, &restSubId1)
6742 deleteXapp2Subscription(t, &restSubId2)
6744 waitSubsCleanup(t, e2SubsId1, 10)
6745 waitSubsCleanup(t, e2SubsId2, 10)
6747 mainCtrl.VerifyCounterValues(t)
6748 mainCtrl.VerifyAllClean(t)
6751 //-----------------------------------------------------------------------------
6752 // TestRESTSubReqDiffActionType
6755 // +-------+ +-------+ +---------+ +---------+
6756 // | xapp2 | | xapp1 | | submgr | | e2term |
6757 // +-------+ +-------+ +---------+ +---------+
6759 // | | RESTSubReq1 | |
6760 // | |------------->| |
6761 // | | RESTSubResp1 | |
6762 // | |<-------------| |
6765 // | | |------------->|
6767 // | RESTSubReq2 | |
6768 // |------------------------>| |
6769 // | RESTSubResp2 | |
6770 // |<------------------------| |
6773 // | | |------------->|
6776 // | | |<-------------|
6777 // | | RESTNotif1 | |
6778 // | |<-------------| |
6781 // | | |<-------------|
6783 // |<------------------------| |
6785 // | | [SUBS 1 DELETE] |
6787 // | | [SUBS 2 DELETE] |
6790 //-----------------------------------------------------------------------------
6792 func TestRESTSubReqDiffActionType(t *testing.T) {
6794 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6795 Counter{cRestSubReqFromXapp, 2},
6796 Counter{cRestSubRespToXapp, 2},
6797 Counter{cSubReqToE2, 2},
6798 Counter{cSubRespFromE2, 2},
6799 Counter{cRestSubNotifToXapp, 2},
6800 Counter{cRestSubDelReqFromXapp, 2},
6801 Counter{cSubDelReqToE2, 2},
6802 Counter{cSubDelRespFromE2, 2},
6803 Counter{cRestSubDelRespToXapp, 2},
6806 const e2Timeout int64 = 2
6807 const e2RetryCount int64 = 2
6808 const routingNeeded bool = true
6811 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6812 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6815 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
6816 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
6818 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
6821 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
6822 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6823 params.SetMeid("RAN_NAME_1")
6825 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
6826 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
6827 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6828 xappConn2.ExpectRESTNotification(t, restSubId2)
6829 e2termConn1.SendSubsResp(t, crereq, cremsg)
6830 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
6832 deleteXapp1Subscription(t, &restSubId1)
6833 deleteXapp2Subscription(t, &restSubId2)
6835 waitSubsCleanup(t, e2SubsId1, 10)
6836 waitSubsCleanup(t, e2SubsId2, 10)
6838 mainCtrl.VerifyCounterValues(t)
6839 mainCtrl.VerifyAllClean(t)
6842 //-----------------------------------------------------------------------------
6843 // TestRESTSubReqPolicyAndSubDelOkSameAction
6846 // +-------+ +-------+ +---------+ +---------+
6847 // | xapp2 | | xapp1 | | submgr | | e2term |
6848 // +-------+ +-------+ +---------+ +---------+
6850 // | | RESTSubReq1 | |
6851 // | |------------->| |
6852 // | | RESTSubResp1 | |
6853 // | |<-------------| |
6856 // | | |------------->|
6858 // | RESTSubReq2 | |
6859 // |------------------------>| |
6860 // | RESTSubResp2 | |
6861 // |<------------------------| |
6864 // | | |------------->|
6867 // | | |<-------------|
6868 // | | RESTNotif1 | |
6869 // | |<-------------| |
6872 // | | |<-------------|
6874 // |<------------------------| |
6876 // | | [SUBS 1 DELETE] |
6878 // | | [SUBS 2 DELETE] |
6881 //-----------------------------------------------------------------------------
6883 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
6885 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6886 Counter{cRestSubReqFromXapp, 2},
6887 Counter{cRestSubRespToXapp, 2},
6888 Counter{cSubReqToE2, 2},
6889 Counter{cSubRespFromE2, 2},
6890 Counter{cRestSubNotifToXapp, 2},
6891 Counter{cRestSubDelReqFromXapp, 2},
6892 Counter{cSubDelReqToE2, 2},
6893 Counter{cSubDelRespFromE2, 2},
6894 Counter{cRestSubDelRespToXapp, 2},
6897 const e2Timeout int64 = 2
6898 const e2RetryCount int64 = 2
6899 const routingNeeded bool = true
6902 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6903 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6906 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
6907 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
6909 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
6912 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
6913 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6914 params.SetMeid("RAN_NAME_1")
6916 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
6917 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
6918 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6919 xappConn2.ExpectRESTNotification(t, restSubId2)
6920 e2termConn1.SendSubsResp(t, crereq, cremsg)
6921 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
6923 deleteXapp1Subscription(t, &restSubId1)
6924 deleteXapp2Subscription(t, &restSubId2)
6926 waitSubsCleanup(t, e2SubsId1, 10)
6927 waitSubsCleanup(t, e2SubsId2, 10)
6929 mainCtrl.VerifyCounterValues(t)
6930 mainCtrl.VerifyAllClean(t)
6933 //-----------------------------------------------------------------------------
6934 // TestRESTSubReqReportSameActionDiffActionDefinitionLen
6937 // +-------+ +-------+ +---------+ +---------+
6938 // | xapp2 | | xapp1 | | submgr | | e2term |
6939 // +-------+ +-------+ +---------+ +---------+
6941 // | | RESTSubReq1 | |
6942 // | |------------->| |
6943 // | | RESTSubResp1 | |
6944 // | |<-------------| |
6947 // | | |------------->|
6949 // | RESTSubReq2 | |
6950 // |------------------------>| |
6951 // | RESTSubResp2 | |
6952 // |<------------------------| |
6955 // | | |------------->|
6958 // | | |<-------------|
6959 // | | RESTNotif1 | |
6960 // | |<-------------| |
6963 // | | |<-------------|
6965 // |<------------------------| |
6967 // | | [SUBS 1 DELETE] |
6969 // | | [SUBS 2 DELETE] |
6972 //-----------------------------------------------------------------------------
6974 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
6976 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6977 Counter{cRestSubReqFromXapp, 2},
6978 Counter{cRestSubRespToXapp, 2},
6979 Counter{cSubReqToE2, 2},
6980 Counter{cSubRespFromE2, 2},
6981 Counter{cRestSubNotifToXapp, 2},
6982 Counter{cRestSubDelReqFromXapp, 2},
6983 Counter{cSubDelReqToE2, 2},
6984 Counter{cSubDelRespFromE2, 2},
6985 Counter{cRestSubDelRespToXapp, 2},
6989 var params *teststube2ap.RESTSubsReqParams = nil
6992 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
6993 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
6995 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
6998 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
6999 params.SetMeid("RAN_NAME_1")
7000 actionDefinition := []int64{5678, 1}
7001 params.SetSubActionDefinition(actionDefinition)
7003 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
7004 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
7005 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7006 xappConn2.ExpectRESTNotification(t, restSubId2)
7007 e2termConn1.SendSubsResp(t, crereq, cremsg)
7008 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
7010 deleteXapp1Subscription(t, &restSubId1)
7011 deleteXapp2Subscription(t, &restSubId2)
7013 waitSubsCleanup(t, e2SubsId1, 10)
7014 waitSubsCleanup(t, e2SubsId2, 10)
7016 mainCtrl.VerifyCounterValues(t)
7017 mainCtrl.VerifyAllClean(t)
7020 //-----------------------------------------------------------------------------
7021 // TestRESTSubReqReportSameActionDiffActionDefinitionContents
7024 // +-------+ +-------+ +---------+ +---------+
7025 // | xapp2 | | xapp1 | | submgr | | e2term |
7026 // +-------+ +-------+ +---------+ +---------+
7028 // | | RESTSubReq1 | |
7029 // | |------------->| |
7030 // | | RESTSubResp1 | |
7031 // | |<-------------| |
7034 // | | |------------->|
7036 // | RESTSubReq2 | |
7037 // |------------------------>| |
7038 // | RESTSubResp2 | |
7039 // |<------------------------| |
7042 // | | |------------->|
7045 // | | |<-------------|
7046 // | | RESTNotif1 | |
7047 // | |<-------------| |
7050 // | | |<-------------|
7052 // |<------------------------| |
7054 // | | [SUBS 1 DELETE] |
7056 // | | [SUBS 2 DELETE] |
7059 //-----------------------------------------------------------------------------
7061 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
7063 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7064 Counter{cRestSubReqFromXapp, 2},
7065 Counter{cRestSubRespToXapp, 2},
7066 Counter{cSubReqToE2, 2},
7067 Counter{cSubRespFromE2, 2},
7068 Counter{cRestSubNotifToXapp, 2},
7069 Counter{cRestSubDelReqFromXapp, 2},
7070 Counter{cSubDelReqToE2, 2},
7071 Counter{cSubDelRespFromE2, 2},
7072 Counter{cRestSubDelRespToXapp, 2},
7076 var params *teststube2ap.RESTSubsReqParams = nil
7079 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
7080 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
7082 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
7085 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
7086 params.SetMeid("RAN_NAME_1")
7087 actionDefinition := []int64{56782}
7088 params.SetSubActionDefinition(actionDefinition)
7090 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
7091 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
7092 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7093 xappConn2.ExpectRESTNotification(t, restSubId2)
7094 e2termConn1.SendSubsResp(t, crereq, cremsg)
7095 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
7097 deleteXapp1Subscription(t, &restSubId1)
7098 deleteXapp2Subscription(t, &restSubId2)
7100 waitSubsCleanup(t, e2SubsId1, 10)
7101 waitSubsCleanup(t, e2SubsId2, 10)
7103 mainCtrl.VerifyCounterValues(t)
7104 mainCtrl.VerifyAllClean(t)
7107 //-----------------------------------------------------------------------------
7108 // TestRESTSubReqReportSameActionDiffSubsAction
7111 // +-------+ +-------+ +---------+ +---------+
7112 // | xapp2 | | xapp1 | | submgr | | e2term |
7113 // +-------+ +-------+ +---------+ +---------+
7115 // | | RESTSubReq1 | |
7116 // | |------------->| |
7117 // | | RESTSubResp1 | |
7118 // | |<-------------| |
7121 // | | |------------->|
7123 // | RESTSubReq2 | |
7124 // |------------------------>| |
7125 // | RESTSubResp2 | |
7126 // |<------------------------| |
7129 // | | |------------->|
7132 // | | |<-------------|
7133 // | | RESTNotif1 | |
7134 // | |<-------------| |
7137 // | | |<-------------|
7139 // |<------------------------| |
7141 // | | [SUBS 1 DELETE] |
7143 // | | [SUBS 2 DELETE] |
7146 //-----------------------------------------------------------------------------
7148 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
7150 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7151 Counter{cRestSubReqFromXapp, 2},
7152 Counter{cRestSubRespToXapp, 2},
7153 Counter{cSubReqToE2, 2},
7154 Counter{cSubRespFromE2, 2},
7155 Counter{cRestSubNotifToXapp, 2},
7156 Counter{cRestSubDelReqFromXapp, 2},
7157 Counter{cSubDelReqToE2, 2},
7158 Counter{cSubDelRespFromE2, 2},
7159 Counter{cRestSubDelRespToXapp, 2},
7163 var params *teststube2ap.RESTSubsReqParams = nil
7166 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
7167 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
7169 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
7172 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
7173 params.SetMeid("RAN_NAME_1")
7174 params.SetTimeToWait("w200ms")
7175 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
7176 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
7177 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7178 xappConn2.ExpectRESTNotification(t, restSubId2)
7179 e2termConn1.SendSubsResp(t, crereq, cremsg)
7180 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
7182 deleteXapp1Subscription(t, &restSubId1)
7183 deleteXapp2Subscription(t, &restSubId2)
7185 waitSubsCleanup(t, e2SubsId1, 10)
7186 waitSubsCleanup(t, e2SubsId2, 10)
7188 mainCtrl.VerifyCounterValues(t)
7189 mainCtrl.VerifyAllClean(t)
7192 //-----------------------------------------------------------------------------
7193 // TestRESTUnpackSubscriptionResponseDecodeFail
7196 // +-------+ +---------+ +---------+
7197 // | xapp | | submgr | | e2term |
7198 // +-------+ +---------+ +---------+
7201 // |---------------->| |
7203 // | RESTSubResp | |
7204 // |<----------------| |
7207 // | |------------->|
7209 // | | SubResp | ASN.1 decode fails
7210 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
7213 // | |------------->|
7215 // | | SubFail | Duplicated action
7216 // | |<-------------|
7217 // | RESTNotif (fail)| |
7218 // |<----------------| |
7220 // | [SUBS DELETE] |
7223 //-----------------------------------------------------------------------------
7225 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
7227 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7228 Counter{cRestSubReqFromXapp, 1},
7229 Counter{cRestSubRespToXapp, 1},
7230 Counter{cSubReqToE2, 1},
7231 Counter{cSubReqTimerExpiry, 1},
7232 Counter{cSubReReqToE2, 1},
7233 Counter{cSubRespFromE2, 1},
7234 Counter{cSubFailFromE2, 1},
7235 Counter{cRestSubFailNotifToXapp, 1},
7236 Counter{cRestSubDelReqFromXapp, 1},
7237 Counter{cRestSubDelRespToXapp, 1},
7240 const subReqCount int = 1
7243 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7244 restSubId := xappConn1.SendRESTSubsReq(t, params)
7246 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7247 // Decode of this response fails which will result resending original request
7248 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
7250 _, cremsg = e2termConn1.RecvSubsReq(t)
7252 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7254 // Subscription already created in E2 Node.
7255 fparams := &teststube2ap.E2StubSubsFailParams{}
7257 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
7258 e2termConn1.SendSubsFail(t, fparams, cremsg)
7260 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
7261 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
7263 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7265 // Wait that subs is cleaned
7266 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
7268 xappConn1.TestMsgChanEmpty(t)
7269 e2termConn1.TestMsgChanEmpty(t)
7270 mainCtrl.wait_registry_empty(t, 10)
7271 mainCtrl.VerifyAllClean(t)
7272 mainCtrl.VerifyCounterValues(t)
7275 //-----------------------------------------------------------------------------
7276 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
7279 // +-------+ +---------+ +---------+
7280 // | xapp | | submgr | | e2term |
7281 // +-------+ +---------+ +---------+
7284 // |---------------->| |
7286 // | RESTSubResp | |
7287 // |<----------------| |
7290 // | |------------->|
7292 // | | SubResp | Unknown instanceId
7293 // | |<-------------| No valid subscription found with subIds [0]
7296 // | |------------->|
7298 // | | SubFail | Duplicated action
7299 // | |<-------------| No valid subscription found with subIds [0]
7300 // | RESTNotif (fail)| |
7301 // |<----------------| |
7303 // | |------------->|
7306 // | |<-------------|
7308 // | [SUBS DELETE] |
7311 //-----------------------------------------------------------------------------
7313 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
7315 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7316 Counter{cRestSubReqFromXapp, 1},
7317 Counter{cRestSubRespToXapp, 1},
7318 Counter{cSubReqToE2, 1},
7319 Counter{cSubReqTimerExpiry, 2},
7320 Counter{cSubReReqToE2, 1},
7321 Counter{cSubRespFromE2, 1},
7322 Counter{cSubFailFromE2, 1},
7323 Counter{cRestSubFailNotifToXapp, 1},
7324 Counter{cRestSubDelReqFromXapp, 1},
7325 Counter{cRestSubDelRespToXapp, 1},
7326 Counter{cSubDelReqToE2, 1},
7327 Counter{cSubDelRespFromE2, 1},
7330 const subReqCount int = 1
7333 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7334 restSubId := xappConn1.SendRESTSubsReq(t, params)
7336 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7338 // Unknown instanceId 0 in this response which will result resending original request
7339 orgInstanceId := crereq.RequestId.InstanceId
7340 crereq.RequestId.InstanceId = 0
7341 e2termConn1.SendSubsResp(t, crereq, cremsg)
7343 _, cremsg = e2termConn1.RecvSubsReq(t)
7345 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7347 // Subscription already created in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
7348 fparams := &teststube2ap.E2StubSubsFailParams{}
7350 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
7351 e2termConn1.SendSubsFail(t, fparams, cremsg)
7353 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7354 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7356 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
7357 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
7359 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7361 // Wait that subs is cleaned
7362 mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
7364 xappConn1.TestMsgChanEmpty(t)
7365 e2termConn1.TestMsgChanEmpty(t)
7366 mainCtrl.wait_registry_empty(t, 10)
7367 mainCtrl.VerifyAllClean(t)
7368 mainCtrl.VerifyCounterValues(t)
7371 //-----------------------------------------------------------------------------
7372 // TestRESTUnpackSubscriptionResponseNoTransaction
7375 // +-------+ +---------+ +---------+
7376 // | xapp | | submgr | | e2term |
7377 // +-------+ +---------+ +---------+
7380 // |---------------->| |
7382 // | RESTSubResp | |
7383 // |<----------------| |
7386 // | |------------->|
7388 // | | SubResp | No transaction for the response
7389 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
7392 // | |------------->|
7394 // | | SubFail | Duplicated action
7395 // | |<-------------|Ongoing transaction not found. This will result timer expiry and sending delete
7396 // | RESTNotif (fail)| |
7397 // |<----------------| |
7399 // | |------------->|
7402 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
7405 // | |------------->|
7408 // | |<-------------| Ongoing transaction not found.
7410 // | [SUBS DELETE] |
7413 //-----------------------------------------------------------------------------
7415 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
7417 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7418 Counter{cRestSubReqFromXapp, 1},
7419 Counter{cRestSubRespToXapp, 1},
7420 Counter{cSubReqToE2, 1},
7421 Counter{cSubReqTimerExpiry, 2},
7422 Counter{cSubReReqToE2, 1},
7423 Counter{cSubRespFromE2, 1},
7424 Counter{cSubFailFromE2, 1},
7425 Counter{cRestSubFailNotifToXapp, 1},
7426 Counter{cRestSubDelReqFromXapp, 1},
7427 Counter{cRestSubDelRespToXapp, 1},
7428 Counter{cSubDelReqToE2, 1},
7429 Counter{cSubDelReqTimerExpiry, 2},
7430 Counter{cSubDelReReqToE2, 1},
7431 Counter{cSubDelRespFromE2, 2},
7434 const subReqCount int = 1
7437 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7438 restSubId := xappConn1.SendRESTSubsReq(t, params)
7440 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7442 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
7443 // No transaction exist for this response which will result resending original request
7444 e2termConn1.SendSubsResp(t, crereq, cremsg)
7446 _, cremsg = e2termConn1.RecvSubsReq(t)
7448 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7450 // Subscription already created in E2 Node.
7451 fparams := &teststube2ap.E2StubSubsFailParams{}
7453 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
7454 e2termConn1.SendSubsFail(t, fparams, cremsg)
7456 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7457 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7459 // Resending happens because there no transaction
7460 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
7461 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7463 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
7464 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
7466 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7468 // Wait that subs is cleaned
7469 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
7471 xappConn1.TestMsgChanEmpty(t)
7472 e2termConn1.TestMsgChanEmpty(t)
7473 mainCtrl.wait_registry_empty(t, 10)
7474 mainCtrl.VerifyAllClean(t)
7475 mainCtrl.VerifyCounterValues(t)
7478 //-----------------------------------------------------------------------------
7479 // TestRESTUnpackSubscriptionFailureDecodeFail
7482 // +-------+ +---------+ +---------+
7483 // | xapp | | submgr | | e2term |
7484 // +-------+ +---------+ +---------+
7487 // |---------------->| |
7489 // | RESTSubResp | |
7490 // |<----------------| |
7493 // | |------------->|
7495 // | | SubFail | ASN.1 decode fails
7496 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
7499 // | |------------->|
7501 // | | SubFail | Duplicated action
7502 // | |<-------------|
7503 // | RESTNotif (fail)| |
7504 // |<----------------| |
7506 // | [SUBS DELETE] |
7509 //-----------------------------------------------------------------------------
7511 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
7513 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7514 Counter{cRestSubReqFromXapp, 1},
7515 Counter{cRestSubRespToXapp, 1},
7516 Counter{cSubReqToE2, 1},
7517 Counter{cSubReqTimerExpiry, 1},
7518 Counter{cSubReReqToE2, 1},
7519 Counter{cSubFailFromE2, 2},
7520 Counter{cRestSubFailNotifToXapp, 1},
7521 Counter{cRestSubDelReqFromXapp, 1},
7522 Counter{cRestSubDelRespToXapp, 1},
7525 const subReqCount int = 1
7528 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7529 restSubId := xappConn1.SendRESTSubsReq(t, params)
7531 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7533 // Decode of this response fails which will result resending original request
7534 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
7536 _, cremsg = e2termConn1.RecvSubsReq(t)
7538 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7540 // Subscription already created in E2 Node.
7541 fparams := &teststube2ap.E2StubSubsFailParams{}
7543 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
7544 e2termConn1.SendSubsFail(t, fparams, cremsg)
7546 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
7547 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
7549 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7551 // Wait that subs is cleaned
7552 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
7554 xappConn1.TestMsgChanEmpty(t)
7555 e2termConn1.TestMsgChanEmpty(t)
7556 mainCtrl.wait_registry_empty(t, 10)
7557 mainCtrl.VerifyAllClean(t)
7558 mainCtrl.VerifyCounterValues(t)
7561 //-----------------------------------------------------------------------------
7562 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
7565 // +-------+ +---------+ +---------+
7566 // | xapp | | submgr | | e2term |
7567 // +-------+ +---------+ +---------+
7570 // |---------------->| |
7572 // | RESTSubResp | |
7573 // |<----------------| |
7576 // | |------------->|
7578 // | | SubFail | Unknown instanceId
7579 // | |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
7582 // | |------------->|
7584 // | | SubFail | Duplicated action
7585 // | |<-------------|No valid subscription found with subIds [0]. This will result timer expiry and sending delete
7586 // | RESTNotif (fail)| |
7587 // |<----------------| |
7589 // | |------------->|
7592 // | |<-------------|
7594 // | [SUBS DELETE] |
7597 //-----------------------------------------------------------------------------
7598 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
7600 const subReqCount int = 1
7602 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7603 Counter{cRestSubReqFromXapp, 1},
7604 Counter{cRestSubRespToXapp, 1},
7605 Counter{cSubReqToE2, 1},
7606 Counter{cSubReqTimerExpiry, 2},
7607 Counter{cSubReReqToE2, 1},
7608 Counter{cSubFailFromE2, 2},
7609 Counter{cRestSubFailNotifToXapp, 1},
7610 Counter{cRestSubDelReqFromXapp, 1},
7611 Counter{cRestSubDelRespToXapp, 1},
7612 Counter{cSubDelReqToE2, 1},
7613 Counter{cSubDelRespFromE2, 1},
7617 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7618 restSubId := xappConn1.SendRESTSubsReq(t, params)
7620 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7622 // Unknown instanceId 0 in this response which will result resending original request
7623 fparams := &teststube2ap.E2StubSubsFailParams{}
7625 fparams.Fail.RequestId.InstanceId = 0
7626 e2termConn1.SendSubsFail(t, fparams, cremsg)
7628 _, cremsg = e2termConn1.RecvSubsReq(t)
7630 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7632 // Subscription already created in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
7633 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
7634 e2termConn1.SendSubsFail(t, fparams, cremsg)
7636 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7637 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7639 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
7640 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
7642 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7644 // Wait that subs is cleaned
7645 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
7647 xappConn1.TestMsgChanEmpty(t)
7648 e2termConn1.TestMsgChanEmpty(t)
7649 mainCtrl.wait_registry_empty(t, 10)
7650 mainCtrl.VerifyAllClean(t)
7651 mainCtrl.VerifyCounterValues(t)
7654 //-----------------------------------------------------------------------------
7655 // TestRESTUnpackSubscriptionFailureNoTransaction
7658 // +-------+ +---------+ +---------+
7659 // | xapp | | submgr | | e2term |
7660 // +-------+ +---------+ +---------+
7663 // |---------------->| |
7665 // | RESTSubResp | |
7666 // |<----------------| |
7669 // | |------------->|
7671 // | | SubFail | No transaction for the response
7672 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
7675 // | |------------->|
7677 // | | SubFail | Duplicated action
7678 // | |<-------------| Ongoing transaction not found. This will result timer expiry and sending delete
7679 // | RESTNotif (fail)| |
7680 // |<----------------| |
7682 // | |------------->|
7685 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
7688 // | |------------->|
7691 // | |<-------------| Ongoing transaction not found.
7693 // | [SUBS DELETE] |
7696 //-----------------------------------------------------------------------------
7698 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
7700 const subReqCount int = 1
7702 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7703 Counter{cRestSubReqFromXapp, 1},
7704 Counter{cRestSubRespToXapp, 1},
7705 Counter{cSubReqToE2, 1},
7706 Counter{cSubReqTimerExpiry, 2},
7707 Counter{cSubReReqToE2, 1},
7708 Counter{cSubFailFromE2, 2},
7709 Counter{cRestSubFailNotifToXapp, 1},
7710 Counter{cRestSubDelReqFromXapp, 1},
7711 Counter{cRestSubDelRespToXapp, 1},
7712 Counter{cSubDelReqToE2, 1},
7713 Counter{cSubDelReqTimerExpiry, 2},
7714 Counter{cSubDelReReqToE2, 1},
7715 Counter{cSubDelRespFromE2, 2},
7719 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7720 restSubId := xappConn1.SendRESTSubsReq(t, params)
7722 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7724 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
7726 // No transaction exist for this response which will result resending original request
7727 fparams := &teststube2ap.E2StubSubsFailParams{}
7729 e2termConn1.SendSubsFail(t, fparams, cremsg)
7731 _, cremsg = e2termConn1.RecvSubsReq(t)
7733 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7735 // Subscription already created in E2 Node.
7736 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
7737 e2termConn1.SendSubsFail(t, fparams, cremsg)
7739 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7740 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7742 // Resending happens because there no transaction
7743 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
7744 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7746 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
7747 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
7749 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7751 // Wait that subs is cleaned
7752 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
7754 xappConn1.TestMsgChanEmpty(t)
7755 e2termConn1.TestMsgChanEmpty(t)
7756 mainCtrl.wait_registry_empty(t, 10)
7757 mainCtrl.VerifyAllClean(t)
7758 mainCtrl.VerifyCounterValues(t)
7761 //-----------------------------------------------------------------------------
7762 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
7765 // +-------+ +---------+ +---------+
7766 // | xapp | | submgr | | e2term |
7767 // +-------+ +---------+ +---------+
7769 // | [SUBS CREATE] |
7772 // | RESTSubDelReq | |
7773 // |---------------->| |
7775 // | RESTSubDelResp | |
7776 // |<----------------| |
7779 // | |------------->|
7781 // | | SubDelResp | ASN.1 decode fails.
7782 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
7785 // | |------------->|
7787 // | | SubDelFail | Subscription does exist any more in E2 node
7788 // | |<-------------|
7790 // | [SUBS DELETE] |
7793 //-----------------------------------------------------------------------------
7795 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
7797 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7798 Counter{cRestSubReqFromXapp, 1},
7799 Counter{cRestSubRespToXapp, 1},
7800 Counter{cSubReqToE2, 1},
7801 Counter{cSubRespFromE2, 1},
7802 Counter{cRestSubNotifToXapp, 1},
7803 Counter{cRestSubDelReqFromXapp, 1},
7804 Counter{cRestSubDelRespToXapp, 1},
7805 Counter{cSubDelReqToE2, 1},
7806 Counter{cSubDelReqTimerExpiry, 1},
7807 Counter{cSubDelReReqToE2, 1},
7808 Counter{cSubDelFailFromE2, 1},
7809 Counter{cSubDelRespFromE2, 1},
7813 var params *teststube2ap.RESTSubsReqParams = nil
7814 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
7817 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7819 // E2t: Receive 1st SubsDelReq
7820 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7822 // Decode of this response fails which will result resending original request
7823 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_RESP)
7825 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
7826 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
7828 // Subscription does not exist in in E2 Node.
7829 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
7831 // Wait that subs is cleaned
7832 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
7834 xappConn1.TestMsgChanEmpty(t)
7835 e2termConn1.TestMsgChanEmpty(t)
7836 mainCtrl.wait_registry_empty(t, 10)
7837 mainCtrl.VerifyAllClean(t)
7838 mainCtrl.VerifyCounterValues(t)
7841 //-----------------------------------------------------------------------------
7842 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
7845 // +-------+ +---------+ +---------+
7846 // | xapp | | submgr | | e2term |
7847 // +-------+ +---------+ +---------+
7849 // | [SUBS CREATE] |
7852 // | RESTSubDelReq | |
7853 // |---------------->| |
7855 // | RESTSubDelResp | |
7856 // |<----------------| |
7859 // | |------------->|
7861 // | | SubDelResp | Unknown instanceId
7862 // | |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
7865 // | |------------->|
7867 // | | SubDelFail | Subscription does exist any more in E2 node
7868 // | |<-------------|
7870 // | [SUBS DELETE] |
7872 //-----------------------------------------------------------------------------
7874 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
7876 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7877 Counter{cRestSubReqFromXapp, 1},
7878 Counter{cRestSubRespToXapp, 1},
7879 Counter{cSubReqToE2, 1},
7880 Counter{cSubRespFromE2, 1},
7881 Counter{cRestSubNotifToXapp, 1},
7882 Counter{cRestSubDelReqFromXapp, 1},
7883 Counter{cRestSubDelRespToXapp, 1},
7884 Counter{cSubDelReqToE2, 1},
7885 Counter{cSubDelReqTimerExpiry, 1},
7886 Counter{cSubDelReReqToE2, 1},
7887 Counter{cSubDelRespFromE2, 1},
7888 Counter{cSubDelFailFromE2, 1},
7892 var params *teststube2ap.RESTSubsReqParams = nil
7893 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
7896 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7898 // E2t: Receive 1st SubsDelReq
7899 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7901 // Unknown instanceId in this response which will result resending original request
7902 delreq.RequestId.InstanceId = 0
7903 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7905 // E2t: Receive 2nd SubsDelReq
7906 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
7908 // Subscription does not exist in in E2 Node.
7909 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
7911 // Wait that subs is cleaned
7912 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
7914 xappConn1.TestMsgChanEmpty(t)
7915 e2termConn1.TestMsgChanEmpty(t)
7916 mainCtrl.wait_registry_empty(t, 10)
7917 mainCtrl.VerifyAllClean(t)
7918 mainCtrl.VerifyCounterValues(t)
7921 //-----------------------------------------------------------------------------
7922 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
7925 // +-------+ +---------+ +---------+
7926 // | xapp | | submgr | | e2term |
7927 // +-------+ +---------+ +---------+
7929 // | [SUBS CREATE] |
7932 // | RESTSubDelReq | |
7933 // |---------------->| |
7935 // | RESTSubDelResp | |
7936 // |<----------------| |
7939 // | |------------->|
7941 // | | SubDelResp | No transaction for the response
7942 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
7945 // | |------------->|
7947 // | | SubDelFail | Subscription does exist any more in E2 node
7948 // | |<-------------| Ongoing transaction not found. This will result timer expiry
7950 // | [SUBS DELETE] |
7952 //-----------------------------------------------------------------------------
7954 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
7956 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7957 Counter{cRestSubReqFromXapp, 1},
7958 Counter{cRestSubRespToXapp, 1},
7959 Counter{cSubReqToE2, 1},
7960 Counter{cSubRespFromE2, 1},
7961 Counter{cRestSubNotifToXapp, 1},
7962 Counter{cRestSubDelReqFromXapp, 1},
7963 Counter{cRestSubDelRespToXapp, 1},
7964 Counter{cSubDelReqToE2, 1},
7965 Counter{cSubDelReqTimerExpiry, 2},
7966 Counter{cSubDelReReqToE2, 1},
7967 Counter{cSubDelRespFromE2, 1},
7968 Counter{cSubDelFailFromE2, 1},
7972 var params *teststube2ap.RESTSubsReqParams = nil
7973 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
7976 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7978 // E2t: Receive 1st SubsDelReq
7979 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7981 mainCtrl.MakeTransactionNil(t, e2SubsId)
7983 // No transaction exist for this response which will result resending original request
7984 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7986 // E2t: Receive 2nd SubsDelReq
7987 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
7989 // Subscription does not exist in in E2 Node.
7990 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
7992 // Wait that subs is cleaned
7993 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
7995 xappConn1.TestMsgChanEmpty(t)
7996 e2termConn1.TestMsgChanEmpty(t)
7997 mainCtrl.wait_registry_empty(t, 10)
7998 mainCtrl.VerifyAllClean(t)
7999 mainCtrl.VerifyCounterValues(t)
8002 //-----------------------------------------------------------------------------
8003 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
8006 // +-------+ +---------+ +---------+
8007 // | xapp | | submgr | | e2term |
8008 // +-------+ +---------+ +---------+
8010 // | [SUBS CREATE] |
8013 // | RESTSubDelReq | |
8014 // |---------------->| |
8016 // | RESTSubDelResp | |
8017 // |<----------------| |
8020 // | |------------->|
8022 // | | SubDelFail | ASN.1 decode fails
8023 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
8026 // | |------------->|
8028 // | | SubDelFail | Subscription does exist any more in E2 node
8029 // | |<-------------|
8031 // | [SUBS DELETE] |
8033 //-----------------------------------------------------------------------------
8035 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
8037 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8038 Counter{cRestSubReqFromXapp, 1},
8039 Counter{cRestSubRespToXapp, 1},
8040 Counter{cSubReqToE2, 1},
8041 Counter{cSubRespFromE2, 1},
8042 Counter{cRestSubNotifToXapp, 1},
8043 Counter{cRestSubDelReqFromXapp, 1},
8044 Counter{cRestSubDelRespToXapp, 1},
8045 Counter{cSubDelReqToE2, 1},
8046 Counter{cSubDelReqTimerExpiry, 1},
8047 Counter{cSubDelReReqToE2, 1},
8048 Counter{cSubDelFailFromE2, 2},
8052 var params *teststube2ap.RESTSubsReqParams = nil
8053 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
8056 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8058 // E2t: Receive 1st SubsDelReq
8059 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8061 // Decode of this response fails which will result resending original request
8062 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
8064 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
8065 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
8067 // Subscription does not exist in in E2 Node.
8068 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
8070 // Wait that subs is cleaned
8071 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
8073 xappConn1.TestMsgChanEmpty(t)
8074 e2termConn1.TestMsgChanEmpty(t)
8075 mainCtrl.wait_registry_empty(t, 10)
8076 mainCtrl.VerifyAllClean(t)
8077 mainCtrl.VerifyCounterValues(t)
8080 //-----------------------------------------------------------------------------
8081 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
8084 // +-------+ +---------+ +---------+
8085 // | xapp | | submgr | | e2term |
8086 // +-------+ +---------+ +---------+
8088 // | [SUBS CREATE] |
8091 // | RESTSubDelReq | |
8092 // |---------------->| |
8094 // | RESTSubDelResp | |
8095 // |<----------------| |
8098 // | |------------->|
8100 // | | SubDelFail | Unknown instanceId
8101 // | |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
8104 // | |------------->|
8106 // | | SubDelFail | Subscription does exist any more in E2 node
8107 // | |<-------------| No valid subscription found with subIds [0].
8109 // | [SUBS DELETE] |
8111 //-----------------------------------------------------------------------------
8113 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
8115 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8116 Counter{cRestSubReqFromXapp, 1},
8117 Counter{cRestSubRespToXapp, 1},
8118 Counter{cSubReqToE2, 1},
8119 Counter{cSubRespFromE2, 1},
8120 Counter{cRestSubNotifToXapp, 1},
8121 Counter{cRestSubDelReqFromXapp, 1},
8122 Counter{cRestSubDelRespToXapp, 1},
8123 Counter{cSubDelReqToE2, 1},
8124 Counter{cSubDelReqTimerExpiry, 1},
8125 Counter{cSubDelReReqToE2, 1},
8126 Counter{cSubDelFailFromE2, 2},
8130 var params *teststube2ap.RESTSubsReqParams = nil
8131 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
8134 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8136 // E2t: Receive 1st SubsDelReq
8137 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8139 // Unknown instanceId 0 in this response which will result resending original request
8140 delreq.RequestId.InstanceId = 0
8141 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
8143 // E2t: Receive 2nd SubsDelReq
8144 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
8146 // Subscription does not exist in in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
8147 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
8149 // Wait that subs is cleaned
8150 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
8152 xappConn1.TestMsgChanEmpty(t)
8153 e2termConn1.TestMsgChanEmpty(t)
8154 mainCtrl.wait_registry_empty(t, 10)
8155 mainCtrl.VerifyAllClean(t)
8156 mainCtrl.VerifyCounterValues(t)
8159 //-----------------------------------------------------------------------------
8160 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
8163 // +-------+ +---------+ +---------+
8164 // | xapp | | submgr | | e2term |
8165 // +-------+ +---------+ +---------+
8167 // | [SUBS CREATE] |
8170 // | RESTSubDelReq | |
8171 // |---------------->| |
8173 // | RESTSubDelResp | |
8174 // |<----------------| |
8177 // | |------------->|
8179 // | | SubDelFail | No transaction for the response
8180 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
8183 // | |------------->|
8185 // | | SubDelFail | Subscription does exist any more in E2 node
8186 // | |<-------------| Ongoing transaction not found. This will result timer expiry
8188 // | [SUBS DELETE] |
8190 //-----------------------------------------------------------------------------
8192 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
8194 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8195 Counter{cRestSubReqFromXapp, 1},
8196 Counter{cRestSubRespToXapp, 1},
8197 Counter{cSubReqToE2, 1},
8198 Counter{cSubRespFromE2, 1},
8199 Counter{cRestSubNotifToXapp, 1},
8200 Counter{cRestSubDelReqFromXapp, 1},
8201 Counter{cRestSubDelRespToXapp, 1},
8202 Counter{cSubDelReqToE2, 1},
8203 Counter{cSubDelReqTimerExpiry, 2},
8204 Counter{cSubDelReReqToE2, 1},
8205 Counter{cSubDelFailFromE2, 2},
8209 var params *teststube2ap.RESTSubsReqParams = nil
8210 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
8213 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8215 // E2t: Receive 1st SubsDelReq
8216 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8218 mainCtrl.MakeTransactionNil(t, e2SubsId)
8220 // No transaction exist for this response which will result resending original request
8221 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
8223 // E2t: Receive 2nd SubsDelReq
8224 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
8226 // Subscription does not exist in in E2 Node.
8227 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
8229 // Wait that subs is cleaned
8230 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
8232 xappConn1.TestMsgChanEmpty(t)
8233 e2termConn1.TestMsgChanEmpty(t)
8234 mainCtrl.wait_registry_empty(t, 10)
8235 mainCtrl.VerifyAllClean(t)
8236 mainCtrl.VerifyCounterValues(t)
8239 //-----------------------------------------------------------------------------
8240 // TestRESTSubReqFailAsn1PackSubReqError
8243 // +-------+ +---------+ +---------+
8244 // | xapp | | submgr | | e2term |
8245 // +-------+ +---------+ +---------+
8248 // |---------------->| |
8250 // | RESTSubResp | |
8251 // |<----------------| |
8253 // | ASN.1 encode fails |
8256 // | |------------->|
8259 // | |<-------------|
8263 // |<----------------| |
8265 // | [SUBS DELETE] |
8268 //-----------------------------------------------------------------------------
8270 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
8272 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8273 Counter{cRestSubReqFromXapp, 1},
8274 Counter{cRestSubRespToXapp, 1},
8275 Counter{cRestSubFailNotifToXapp, 1},
8276 Counter{cRestSubDelReqFromXapp, 1},
8277 Counter{cRestSubDelRespToXapp, 1},
8280 const subReqCount int = 1
8282 var params *teststube2ap.RESTSubsReqParams = nil
8283 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
8284 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
8287 restSubId := xappConn1.SendRESTSubsReq(t, params)
8288 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
8290 // E2t: Receive SubsDelReq
8291 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
8293 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8294 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
8296 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
8298 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8300 // Wait that subs is cleaned
8301 waitSubsCleanup(t, e2SubsId, 10)
8302 mainCtrl.VerifyAllClean(t)
8303 mainCtrl.VerifyCounterValues(t)
8306 //-----------------------------------------------------------------------------
8307 // TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction
8310 // +-------+ +---------+ +---------+
8311 // | xapp | | submgr | | e2term |
8312 // +-------+ +---------+ +---------+
8315 // |---------------->| |
8317 // | RESTSubResp | |
8318 // |<----------------| |
8320 // | |------------->|
8323 // | |<-------------|
8326 // |<----------------| |
8328 // | RESTSubReq | | Policy modification
8329 // |---------------->| |
8331 // | RESTSubResp | |
8332 // |<----------------| |
8334 // | |------------->|
8337 // | RESTNotif(Unsuccessful) | E2 timeout
8338 // |<----------------| |
8340 // | RESTSubDelReq | |
8341 // |---------------->| |
8344 // | |------------->|
8347 // | |<-------------|
8349 // | RESTSubDelResp | |
8350 // |<----------------| |
8352 //-----------------------------------------------------------------------------
8354 func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
8356 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8357 Counter{cRestSubReqFromXapp, 2},
8358 Counter{cRestSubRespToXapp, 2},
8359 Counter{cSubReqToE2, 2},
8360 Counter{cSubReqTimerExpiry, 1},
8361 Counter{cSubRespFromE2, 1},
8362 Counter{cRestSubNotifToXapp, 1},
8363 Counter{cRestSubFailNotifToXapp, 1},
8364 Counter{cRestSubDelReqFromXapp, 1},
8365 Counter{cSubDelReqToE2, 1},
8366 Counter{cSubDelRespFromE2, 1},
8367 Counter{cRestSubDelRespToXapp, 1},
8370 const e2Timeout int64 = 1
8371 const e2RetryCount int64 = 0
8372 const routingNeeded bool = false
8375 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
8376 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
8379 restSubId := xappConn1.SendRESTSubsReq(t, params)
8380 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
8382 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
8383 xappConn1.ExpectRESTNotification(t, restSubId)
8384 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
8385 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8386 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
8389 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
8390 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
8391 params.SetSubscriptionID(&restSubId)
8392 params.SetTimeToWait("w200ms")
8393 restSubId = xappConn1.SendRESTSubsReq(t, params)
8394 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
8396 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
8397 xappConn1.ExpectRESTNotification(t, restSubId)
8398 // SubsResp is missing, e2SubsId will be 0
8399 zeroE2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8400 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", zeroE2SubsId)
8403 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8404 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8405 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8407 waitSubsCleanup(t, e2SubsId, 10)
8408 mainCtrl.VerifyAllClean(t)
8409 mainCtrl.VerifyCounterValues(t)
8412 //-----------------------------------------------------------------------------
8413 // TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle
8416 // +-------+ +---------+ +---------+
8417 // | xapp | | submgr | | e2term |
8418 // +-------+ +---------+ +---------+
8421 // |---------------->| |
8423 // | RESTSubResp | |
8424 // |<----------------| |
8426 // | |------------->|
8429 // | |<-------------|
8432 // |<----------------| |
8435 // |---------------->| |
8437 // | RESTSubResp | |
8438 // |<----------------| |
8440 // | |------------->|
8442 // | Submgr restart |
8444 // | RESTSubDelReq | |
8445 // |---------------->| |
8448 // | |------------->|
8451 // | |<-------------|
8453 // | RESTSubDelResp | |
8454 // |<----------------| |
8456 //-----------------------------------------------------------------------------
8458 func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
8460 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8461 Counter{cRestSubReqFromXapp, 2},
8462 Counter{cRestSubRespToXapp, 2},
8463 Counter{cSubReqToE2, 2},
8464 Counter{cSubRespFromE2, 1},
8465 Counter{cRestSubNotifToXapp, 1},
8466 Counter{cRestSubDelReqFromXapp, 1},
8467 Counter{cSubDelReqToE2, 1},
8468 Counter{cSubDelRespFromE2, 1},
8469 Counter{cRestSubDelRespToXapp, 1},
8472 const e2Timeout int64 = 1
8473 const e2RetryCount int64 = 0
8474 const routingNeeded bool = false
8477 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
8478 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
8479 // Create subscription
8480 restSubId := xappConn1.SendRESTSubsReq(t, params)
8481 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
8483 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
8484 xappConn1.ExpectRESTNotification(t, restSubId)
8485 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
8486 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8487 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
8489 // Check subscription
8490 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
8493 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
8494 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
8495 params.SetSubscriptionID(&restSubId)
8496 params.SetTimeToWait("w200ms")
8497 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
8498 restSubId = xappConn1.SendRESTSubsReq(t, params)
8499 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
8501 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
8502 mainCtrl.SetResetTestFlag(t, false)
8504 // SubsResp is missing due to submgr restart
8506 mainCtrl.SimulateRestart(t)
8507 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
8509 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
8510 // That needs to be completed before successful subscription query is possible
8511 <-time.After(time.Second * 1)
8513 // Check subscription
8514 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
8516 // Delete subscription
8517 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8518 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8519 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8521 //Wait that subs is cleaned
8522 waitSubsCleanup(t, e2SubsId, 10)
8524 mainCtrl.VerifyCounterValues(t)
8525 mainCtrl.VerifyAllClean(t)
8528 ////////////////////////////////////////////////////////////////////////////////////
8529 // Services for UT cases
8530 ////////////////////////////////////////////////////////////////////////////////////
8531 const subReqCount int = 1
8532 const host string = "localhost"
8534 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
8536 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
8538 restSubId := fromXappConn.SendRESTSubsReq(t, params)
8539 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
8541 crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
8542 fromXappConn.ExpectRESTNotification(t, restSubId)
8543 toE2termConn.SendSubsResp(t, crereq1, cremsg1)
8544 e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
8545 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
8547 return restSubId, e2SubsId
8550 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
8552 params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
8554 params.SetMeid(meid)
8556 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
8557 restSubId := xappConn2.SendRESTSubsReq(t, params)
8558 xappConn2.ExpectRESTNotification(t, restSubId)
8559 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
8560 e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
8561 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
8563 return restSubId, e2SubsId
8566 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
8568 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
8569 restSubId := xappConn1.SendRESTSubsReq(t, params)
8570 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
8572 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
8573 xappConn1.ExpectRESTNotification(t, restSubId)
8574 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
8575 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8576 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
8578 return restSubId, e2SubsId
8581 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
8582 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
8583 restSubId := xappConn1.SendRESTSubsReq(t, params)
8585 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
8586 fparams1 := &teststube2ap.E2StubSubsFailParams{}
8587 fparams1.Set(crereq1)
8588 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
8590 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
8591 xappConn1.ExpectRESTNotification(t, restSubId)
8592 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
8593 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8594 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
8596 return restSubId, e2SubsId
8599 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
8600 fromXappConn.SendRESTSubsDelReq(t, restSubId)
8601 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
8602 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
8605 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
8606 xappConn1.SendRESTSubsDelReq(t, restSubId)
8607 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8608 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8611 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
8612 xappConn2.SendRESTSubsDelReq(t, restSubId)
8613 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8614 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8617 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
8618 resp, _ := xapp.Subscription.QuerySubscriptions()
8619 assert.Equal(t, e2SubsId, resp[0].SubscriptionID)
8620 assert.Equal(t, meid, resp[0].Meid)
8621 assert.Equal(t, endpoint, resp[0].ClientEndpoint)
8624 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
8625 //Wait that subs is cleaned
8626 mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
8628 xappConn1.TestMsgChanEmpty(t)
8629 xappConn2.TestMsgChanEmpty(t)
8630 e2termConn1.TestMsgChanEmpty(t)
8631 mainCtrl.wait_registry_empty(t, timeout)
8634 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
8636 var e2SubsId []uint32
8638 for i := 0; i < count; i++ {
8639 xapp.Logger.Debug("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
8640 crereq, cremsg := toE2termConn.RecvSubsReq(t)
8641 fromXappConn.ExpectRESTNotification(t, restSubId)
8642 toE2termConn.SendSubsResp(t, crereq, cremsg)
8643 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
8644 e2SubsId = append(e2SubsId, instanceId)
8645 xapp.Logger.Debug("TEST: %v", e2SubsId)
8646 xapp.Logger.Debug("TEST: %d ===================================== END CRE ============================================", i+1)
8647 <-time.After(100 * time.Millisecond)
8652 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
8654 for i := 0; i < len(e2SubsIds); i++ {
8655 xapp.Logger.Debug("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
8656 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
8657 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
8658 <-time.After(1 * time.Second)
8659 xapp.Logger.Debug("TEST: %d ===================================== END DEL ============================================", i+1)
8660 <-time.After(100 * time.Millisecond)
8663 // Wait that subs is cleaned
8664 for i := 0; i < len(e2SubsIds); i++ {
8665 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)