2 ==================================================================================
3 Copyright (c) 2019 AT&T Intellectual Property.
4 Copyright (c) 2019 Nokia
6 Licensed under the Apache License, Version 2.0 (the "License");
7 you may not use this file except in compliance with the License.
8 You may obtain a copy of the License at
10 http://www.apache.org/licenses/LICENSE-2.0
12 Unless required by applicable law or agreed to in writing, software
13 distributed under the License is distributed on an "AS IS" BASIS,
14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 See the License for the specific language governing permissions and
16 limitations under the License.
17 ==================================================================================
28 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
29 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper"
30 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
31 "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststube2ap"
32 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
33 "github.com/stretchr/testify/assert"
36 func TestSuiteSetup(t *testing.T) {
37 // The effect of this call shall endure though the UT suite!
38 // If this causes any issues, the previous interface can be restored
40 // SetPackerIf(e2ap_wrapper.NewAsn1E2APPacker())
42 mainCtrl.InitAllCounterMap()
43 SetPackerIf(e2ap_wrapper.NewUtAsn1E2APPacker())
44 mainCtrl.c.restDuplicateCtrl.Init()
47 func TestRanStatusChangeViaSDLNotification(t *testing.T) {
49 // Current UT test cases use these ran names
50 xappRnibMock.CreateGnb("RAN_NAME_1", entities.ConnectionStatus_DISCONNECTED)
51 xappRnibMock.CreateGnb("RAN_NAME_11", entities.ConnectionStatus_DISCONNECTED)
52 xappRnibMock.CreateGnb("RAN_NAME_2", entities.ConnectionStatus_DISCONNECTED)
54 mainCtrl.c.e2IfState.ReadE2ConfigurationFromRnib()
55 mainCtrl.c.e2IfState.SubscribeChannels()
57 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
58 mainCtrl.SetE2State(t, "RAN_NAME_2_CONNECTED")
59 mainCtrl.SetE2State(t, "RAN_NAME_11_CONNECTED")
62 //-----------------------------------------------------------------------------
63 // TestRESTSubReqAfterE2ConnBreak
66 // +-------+ +---------+ +---------+
67 // | xapp | | submgr | | e2term |
68 // +-------+ +---------+ +---------+
70 // | [E2 Conn. DOWN] |
73 // |---------------->| |
75 // |<----------------| |
78 //-----------------------------------------------------------------------------
80 func TestRESTSubReqAfterE2ConnBreak(t *testing.T) {
81 CaseBegin("TestRESTSubReqAfterE2ConnBreak")
83 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
84 Counter{cRestSubReqFromXapp, 1},
85 Counter{cRestReqRejDueE2Down, 1},
88 // E2 disconnect after E2term has received response
89 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
91 const subReqCount int = 1
92 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
93 xappConn1.SendRESTSubsReq(t, params)
95 // Restore E2 connection for following test cases
96 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
98 mainCtrl.VerifyCounterValues(t)
99 mainCtrl.VerifyAllClean(t)
103 //-----------------------------------------------------------------------------
104 // TestRESTSubReqE2ConnBreak
107 // +-------+ +---------+ +---------+
108 // | xapp | | submgr | | e2term |
109 // +-------+ +---------+ +---------+
112 // |---------------->| |
114 // |<----------------| |
116 // | |------------->|
118 // | |<-------------|
120 // | [E2 Conn. DOWN] |
121 // | [Int. SUBS DELETE] |
123 // | RESTNotif(unsuccessful) |
124 // |<----------------| |
128 //-----------------------------------------------------------------------------
129 func TestRESTSubReqE2ConnBreak(t *testing.T) {
130 CaseBegin("TestRESTSubReqE2ConnBreak")
132 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
133 Counter{cRestSubReqFromXapp, 1},
134 Counter{cRestSubRespToXapp, 1},
135 Counter{cSubReqToE2, 1},
136 Counter{cSubRespFromE2, 1},
137 Counter{cRestSubFailNotifToXapp, 1},
141 const subReqCount int = 1
142 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
143 restSubId := xappConn1.SendRESTSubsReq(t, params)
145 crereq, cremsg := e2termConn1.RecvSubsReq(t)
146 xappConn1.ExpectRESTNotification(t, restSubId)
148 // E2 disconnect after E2term has received response
149 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
151 e2termConn1.SendSubsResp(t, crereq, cremsg)
152 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
154 <-time.After(time.Second * 1)
155 assert.Equal(t, 0, len(mainCtrl.c.registry.register))
156 assert.Equal(t, 0, len(mainCtrl.c.registry.restSubscriptions))
158 subIds, register, err := mainCtrl.c.ReadAllSubscriptionsFromSdl()
160 xapp.Logger.Error("%v", err)
162 assert.Equal(t, 65534, len(subIds)) // range 1-65535 , FFFF = 65535
163 assert.Equal(t, 0, len(register))
166 restSubscriptions, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
168 xapp.Logger.Error("%v", err)
170 assert.Equal(t, 0, len(restSubscriptions))
173 // Restore E2 connection for following test cases
174 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
176 // Wait that subs is cleaned
177 waitSubsCleanup(t, e2SubsId, 10)
178 mainCtrl.VerifyCounterValues(t)
179 mainCtrl.VerifyAllClean(t)
182 //-----------------------------------------------------------------------------
183 // TestRESTSubscriptionDeleteAfterE2ConnectionBreak
186 // +-------+ +---------+ +---------+
187 // | xapp | | submgr | | e2term |
188 // +-------+ +---------+ +---------+
192 // | [E2 Conn. DOWN] |
194 // | RESTSubDelReq | |
195 // |---------------->| |
197 // | RESTSubDelResp | |
198 // |<----------------| |
200 // | [No valid subscription found] |
203 //-----------------------------------------------------------------------------
204 func TestRESTSubscriptionDeleteAfterE2ConnectionBreak(t *testing.T) {
205 xapp.Logger.Debug("TEST: TestRESTSubscriptionDeleteAfterE2ConnectionBreak")
207 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
208 Counter{cRestSubReqFromXapp, 1},
209 Counter{cRestSubRespToXapp, 1},
210 Counter{cSubReqToE2, 1},
211 Counter{cSubRespFromE2, 1},
212 Counter{cRestSubNotifToXapp, 1},
213 Counter{cRestSubDelReqFromXapp, 1},
214 Counter{cRestSubDelRespToXapp, 1},
218 var params *teststube2ap.RESTSubsReqParams = nil
219 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
221 // E2 disconnect after E2term has received response
222 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
225 xappConn1.SendRESTSubsDelReq(t, &restSubId)
227 <-time.After(time.Second * 1)
228 assert.Equal(t, 0, len(mainCtrl.c.registry.register))
229 assert.Equal(t, 0, len(mainCtrl.c.registry.restSubscriptions))
231 subIds, register, err := mainCtrl.c.ReadAllSubscriptionsFromSdl()
233 xapp.Logger.Error("%v", err)
235 assert.Equal(t, 65534, len(subIds)) // range 1-65535 , FFFF = 65535
236 assert.Equal(t, 0, len(register))
239 restSubscriptions, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
241 xapp.Logger.Error("%v", err)
243 assert.Equal(t, 0, len(restSubscriptions))
246 // Restore E2 connection for following test cases
247 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
249 // Wait that subs is cleaned
250 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
252 xappConn1.TestMsgChanEmpty(t)
253 e2termConn1.TestMsgChanEmpty(t)
254 mainCtrl.wait_registry_empty(t, 10)
255 mainCtrl.VerifyCounterValues(t)
256 mainCtrl.VerifyAllClean(t)
259 //-----------------------------------------------------------------------------
260 // TestRESTOtherE2ConnectionChanges
264 // +-------+ +---------+ +---------+
265 // | xapp | | submgr | | e2term |
266 // +-------+ +---------+ +---------+
270 // | [E2 CONNECTED_SETUP_FAILED] |
271 // | [E2 CONNECTING] |
272 // | [E2 SHUTTING_DOWN] |
273 // | [E2 SHUT_DOWN] |
278 //-----------------------------------------------------------------------------
279 func TestRESTOtherE2ConnectionChanges(t *testing.T) {
280 xapp.Logger.Debug("TEST: TestRESTOtherE2ConnectionChanges")
282 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
283 Counter{cRestSubReqFromXapp, 1},
284 Counter{cRestSubRespToXapp, 1},
285 Counter{cSubReqToE2, 1},
286 Counter{cSubRespFromE2, 1},
287 Counter{cRestSubNotifToXapp, 1},
288 Counter{cRestSubDelReqFromXapp, 1},
289 Counter{cSubDelReqToE2, 1},
290 Counter{cSubDelRespFromE2, 1},
291 Counter{cRestSubDelRespToXapp, 1},
295 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
296 restSubId := xappConn1.SendRESTSubsReq(t, params)
298 crereq, cremsg := e2termConn1.RecvSubsReq(t)
299 xappConn1.ExpectRESTNotification(t, restSubId)
300 e2termConn1.SendSubsResp(t, crereq, cremsg)
301 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
303 // Submgr should not react any other connection state changes than CONNECTED and DISCONNECTED
304 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED_SETUP_FAILED")
305 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTING")
306 mainCtrl.SetE2State(t, "RAN_NAME_1_SHUTTING_DOWN")
307 mainCtrl.SetE2State(t, "RAN_NAME_1_SHUT_DOWN")
310 xappConn1.SendRESTSubsDelReq(t, &restSubId)
311 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
312 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
314 // Restore E2 connection for following test cases
315 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
317 // Wait that subs is cleaned
318 waitSubsCleanup(t, e2SubsId, 10)
319 mainCtrl.VerifyCounterValues(t)
320 mainCtrl.VerifyAllClean(t)
323 //-----------------------------------------------------------------------------
324 // TestRESTSubReqAndDeleteOkWithE2apUtWrapper
327 // +-------+ +---------+ +---------+ +---------+
328 // | xapp | | submgr | | e2term | | rtmgr |
329 // +-------+ +---------+ +---------+ +---------+
331 // | RESTSubReq | | |
332 // |---------------->| | |
333 // | | RouteCreate | |
334 // | |--------------------------->| // The order of these events may vary
336 // | RESTSubResp | | | // The order of these events may vary
337 // |<----------------| | |
338 // | | RouteResponse| |
339 // | |<---------------------------| // The order of these events may vary
342 // | |------------->| | // The order of these events may vary
345 // | |<-------------| |
346 // | RESTNotif1 | | |
347 // |<----------------| | |
349 // | RESTSubDelReq | | |
350 // |---------------->| | |
352 // | |------------->| |
354 // | RESTSubDelResp| | |
355 // |<----------------| | |
357 // | | SubDelResp | |
358 // | |<-------------| |
362 //-----------------------------------------------------------------------------
363 func TestRESTSubReqAndDeleteOkWithE2apUtWrapper(t *testing.T) {
365 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
367 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
369 waitSubsCleanup(t, e2SubsId, 10)
370 mainCtrl.VerifyAllClean(t)
373 //-----------------------------------------------------------------------------
374 // TestRESTSubReqAndE1apDeleteReqPackingError
377 // +-------+ +---------+ +---------+ +---------+
378 // | xapp | | submgr | | e2term | | rtmgr |
379 // +-------+ +---------+ +---------+ +---------+
381 // | RESTSubReq | | |
382 // |---------------->| | |
383 // | | RouteCreate | |
384 // | |--------------------------->| // The order of these events may vary
386 // | RESTSubResp | | | // The order of these events may vary
387 // |<----------------| | |
388 // | | RouteResponse| |
389 // | |<---------------------------| // The order of these events may vary
392 // | |------------->| | // The order of these events may vary
395 // | |<-------------| |
396 // | RESTNotif1 | | |
397 // |<----------------| | |
399 // | RESTSubDelReq | | |
400 // |---------------->| | |
402 // | RESTSubDelResp| | |
403 // |<----------------| | |
407 //-----------------------------------------------------------------------------
408 func TestRESTSubReqAndE1apDeleteReqPackingError(t *testing.T) {
410 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
412 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, false)
413 xappConn1.SendRESTSubsDelReq(t, &restSubId)
414 defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, true)
416 waitSubsCleanup(t, e2SubsId, 10)
417 mainCtrl.VerifyAllClean(t)
420 //-----------------------------------------------------------------------------
421 // TestRESTSubReqAndE1apDeleteRespUnpackingError
424 // +-------+ +---------+ +---------+ +---------+
425 // | xapp | | submgr | | e2term | | rtmgr |
426 // +-------+ +---------+ +---------+ +---------+
428 // | RESTSubReq | | |
429 // |---------------->| | |
430 // | | RouteCreate | |
431 // | |--------------------------->| // The order of these events may vary
433 // | RESTSubResp | | | // The order of these events may vary
434 // |<----------------| | |
435 // | | RouteResponse| |
436 // | |<---------------------------| // The order of these events may vary
439 // | |------------->| | // The order of these events may vary
442 // | |<-------------| |
443 // | RESTNotif1 | | |
444 // |<----------------| | |
446 // | RESTSubDelReq | | |
447 // |---------------->| | |
449 // | |------------->| |
451 // | RESTSubDelResp| | |
452 // |<----------------| | | // The order of these events may vary
454 // | | SubDelResp | |
455 // | |<-------------| | // 1.st NOK
458 // | |------------->| |
460 // | | SubDelResp | |
461 // | |<-------------| | // 2.nd NOK
463 //-----------------------------------------------------------------------------
465 func TestRESTSubReqAndE1apDeleteRespUnpackingError(t *testing.T) {
467 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
469 xappConn1.SendRESTSubsDelReq(t, &restSubId)
470 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, false)
471 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
472 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
474 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
475 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
477 defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, true)
479 waitSubsCleanup(t, e2SubsId, 10)
480 mainCtrl.VerifyAllClean(t)
483 //-----------------------------------------------------------------------------
484 // TestSubReqAndRouteNok
487 // +-------+ +---------+ +---------+
488 // | xapp | | submgr | | rtmgr |
489 // +-------+ +---------+ +---------+
492 // |------------->| |
495 // | |------------->|
499 // | |<-------------|
501 // | [SUBS INT DELETE] |
504 //-----------------------------------------------------------------------------
506 func TestSubReqAndRouteNok(t *testing.T) {
507 CaseBegin("TestSubReqAndRouteNok")
509 // Init counter check
510 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
511 Counter{cSubReqFromXapp, 1},
512 Counter{cRouteCreateFail, 1},
515 waiter := rtmgrHttp.AllocNextEvent(false)
516 newSubsId := mainCtrl.get_registry_next_subid(t)
517 xappConn1.SendSubsReq(t, nil, nil)
520 //Wait that subs is cleaned
521 mainCtrl.wait_subs_clean(t, newSubsId, 10)
523 xappConn1.TestMsgChanEmpty(t)
524 xappConn2.TestMsgChanEmpty(t)
525 e2termConn1.TestMsgChanEmpty(t)
526 mainCtrl.wait_registry_empty(t, 10)
528 <-time.After(1 * time.Second)
529 mainCtrl.VerifyCounterValues(t)
532 //-----------------------------------------------------------------------------
533 // TestSubReqAndRouteUpdateNok
536 // +-------+ +-------+ +---------+ +---------+
537 // | xapp2 | | xapp1 | | submgr | | rtmgr |
538 // +-------+ +-------+ +---------+ +---------+
540 // | [SUBS CREATE] | |
544 // | SubReq (mergeable) | |
545 // |--------------------------->| | |
547 // | | | RouteUpdate |
548 // | | |------------->|
550 // | | | RouteUpdate |
551 // | | | status:400 |
552 // | | |<-------------|
554 // | [SUBS INT DELETE] | |
557 // | [SUBS DELETE] | |
560 func TestSubReqAndRouteUpdateNok(t *testing.T) {
561 CaseBegin("TestSubReqAndRouteUpdateNok")
563 // Init counter check
564 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
565 Counter{cSubReqFromXapp, 2},
566 Counter{cSubReqToE2, 1},
567 Counter{cSubRespFromE2, 1},
568 Counter{cSubRespToXapp, 1},
569 Counter{cRouteCreateUpdateFail, 1},
570 Counter{cSubDelReqFromXapp, 1},
571 Counter{cSubDelReqToE2, 1},
572 Counter{cSubDelRespFromE2, 1},
573 Counter{cSubDelRespToXapp, 1},
576 cretrans := xappConn1.SendSubsReq(t, nil, nil)
577 crereq, cremsg := e2termConn1.RecvSubsReq(t)
578 e2termConn1.SendSubsResp(t, crereq, cremsg)
579 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
581 resp, _ := xapp.Subscription.QuerySubscriptions()
582 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
583 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
584 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
586 waiter := rtmgrHttp.AllocNextEvent(false)
587 newSubsId := mainCtrl.get_registry_next_subid(t)
588 xappConn2.SendSubsReq(t, nil, nil)
591 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
592 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
594 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
595 xappConn1.RecvSubsDelResp(t, deltrans)
597 //Wait that subs is cleaned
598 mainCtrl.wait_subs_clean(t, newSubsId, 10)
599 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
601 xappConn1.TestMsgChanEmpty(t)
602 xappConn2.TestMsgChanEmpty(t)
603 e2termConn1.TestMsgChanEmpty(t)
604 mainCtrl.wait_registry_empty(t, 10)
606 mainCtrl.VerifyCounterValues(t)
609 //-----------------------------------------------------------------------------
610 // TestSubDelReqAndRouteDeleteNok
613 // +-------+ +---------+ +---------+ +---------+
614 // | xapp | | submgr | | e2term | | rtmgr |
615 // +-------+ +---------+ +---------+ +---------+
617 // | [SUBS CREATE] | |
622 // |------------->| | |
624 // | |------------->| |
626 // | |<-------------| |
628 // |<-------------| | |
629 // | | RouteDelete | |
630 // | |---------------------------->|
632 // | | RouteDelete | |
633 // | | status:400 | |
634 // | |<----------------------------|
636 func TestSubDelReqAndRouteDeleteNok(t *testing.T) {
637 CaseBegin("TestSubDelReqAndRouteDeleteNok")
639 // Init counter check
640 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
641 Counter{cSubReqFromXapp, 1},
642 Counter{cSubReqToE2, 1},
643 Counter{cSubRespFromE2, 1},
644 Counter{cSubRespToXapp, 1},
645 Counter{cSubDelReqFromXapp, 1},
646 Counter{cRouteDeleteFail, 1},
647 Counter{cSubDelReqToE2, 1},
648 Counter{cSubDelRespFromE2, 1},
649 Counter{cSubDelRespToXapp, 1},
652 cretrans := xappConn1.SendSubsReq(t, nil, nil)
653 crereq, cremsg := e2termConn1.RecvSubsReq(t)
654 e2termConn1.SendSubsResp(t, crereq, cremsg)
655 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
657 resp, _ := xapp.Subscription.QuerySubscriptions()
658 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
659 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
660 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
662 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
663 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
665 waiter := rtmgrHttp.AllocNextEvent(false)
666 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
669 xappConn1.RecvSubsDelResp(t, deltrans)
671 //Wait that subs is cleaned
672 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
674 xappConn1.TestMsgChanEmpty(t)
675 xappConn2.TestMsgChanEmpty(t)
676 e2termConn1.TestMsgChanEmpty(t)
677 mainCtrl.wait_registry_empty(t, 10)
678 mainCtrl.VerifyCounterValues(t)
681 //-----------------------------------------------------------------------------
682 // TestSubMergeDelAndRouteUpdateNok
684 // +-------+ +-------+ +---------+ +---------+
685 // | xapp2 | | xapp1 | | submgr | | e2term |
686 // +-------+ +-------+ +---------+ +---------+
691 // | |------------->| |
694 // | | |------------->|
696 // | | |<-------------|
698 // | |<-------------| |
701 // |--------------------------->| |
704 // |<---------------------------| |
706 // | | SubDelReq 1 | |
707 // | |------------->| |
708 // | | | RouteUpdate |
709 // | | |-----> rtmgr |
711 // | | | RouteUpdate |
712 // | | | status:400 |
713 // | | |<----- rtmgr |
715 // | | SubDelResp 1 | |
716 // | |<-------------| |
719 // |--------------------------->| |
721 // | | | SubDelReq 2 |
722 // | | |------------->|
724 // | | | SubDelReq 2 |
725 // | | |------------->|
727 // | SubDelResp 2 | |
728 // |<---------------------------| |
730 //-----------------------------------------------------------------------------
731 func TestSubMergeDelAndRouteUpdateNok(t *testing.T) {
732 CaseBegin("TestSubMergeDelAndRouteUpdateNok")
734 // Init counter check
735 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
736 Counter{cSubReqFromXapp, 2},
737 Counter{cMergedSubscriptions, 1},
738 Counter{cSubReqToE2, 1},
739 Counter{cSubRespFromE2, 1},
740 Counter{cSubRespToXapp, 2},
741 Counter{cSubDelReqFromXapp, 2},
742 Counter{cRouteDeleteUpdateFail, 1},
743 Counter{cSubDelReqToE2, 1},
744 Counter{cSubDelRespFromE2, 1},
745 Counter{cSubDelRespToXapp, 2},
746 Counter{cUnmergedSubscriptions, 1},
750 rparams1 := &teststube2ap.E2StubSubsReqParams{}
752 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
753 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
754 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
755 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
758 rparams2 := &teststube2ap.E2StubSubsReqParams{}
760 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
761 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
763 resp, _ := xapp.Subscription.QuerySubscriptions()
764 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
765 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
766 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
769 waiter := rtmgrHttp.AllocNextEvent(false)
770 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
773 xappConn1.RecvSubsDelResp(t, deltrans1)
776 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
777 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
778 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
779 xappConn2.RecvSubsDelResp(t, deltrans2)
780 //Wait that subs is cleaned
781 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
783 xappConn1.TestMsgChanEmpty(t)
784 xappConn2.TestMsgChanEmpty(t)
785 e2termConn1.TestMsgChanEmpty(t)
786 mainCtrl.wait_registry_empty(t, 10)
788 mainCtrl.VerifyCounterValues(t)
791 //-----------------------------------------------------------------------------
793 //-----------------------------------------------------------------------------
794 // TestSubReqAndSubDelOk
797 // +-------+ +---------+ +---------+
798 // | xapp | | submgr | | e2term |
799 // +-------+ +---------+ +---------+
802 // |------------->| |
805 // | |------------->|
808 // | |<-------------|
811 // |<-------------| |
815 // |------------->| |
818 // | |------------->|
821 // | |<-------------|
824 // |<-------------| |
826 //-----------------------------------------------------------------------------
827 func TestSubReqAndSubDelOk(t *testing.T) {
828 CaseBegin("TestSubReqAndSubDelOk")
830 // Init counter check
831 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
832 Counter{cSubReqFromXapp, 1},
833 Counter{cSubReqToE2, 1},
834 Counter{cSubRespFromE2, 1},
835 Counter{cSubRespToXapp, 1},
836 Counter{cSubDelReqFromXapp, 1},
837 Counter{cSubDelReqToE2, 1},
838 Counter{cSubDelRespFromE2, 1},
839 Counter{cSubDelRespToXapp, 1},
842 cretrans := xappConn1.SendSubsReq(t, nil, nil)
843 crereq, cremsg := e2termConn1.RecvSubsReq(t)
844 e2termConn1.SendSubsResp(t, crereq, cremsg)
845 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
847 resp, _ := xapp.Subscription.QuerySubscriptions()
848 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
849 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
850 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
852 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
853 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
855 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
856 xappConn1.RecvSubsDelResp(t, deltrans)
858 //Wait that subs is cleaned
859 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
861 xappConn1.TestMsgChanEmpty(t)
862 xappConn2.TestMsgChanEmpty(t)
863 e2termConn1.TestMsgChanEmpty(t)
864 mainCtrl.wait_registry_empty(t, 10)
866 mainCtrl.VerifyCounterValues(t)
869 //-----------------------------------------------------------------------------
870 // TestSubReqRetransmission
873 // +-------+ +---------+ +---------+
874 // | xapp | | submgr | | e2term |
875 // +-------+ +---------+ +---------+
878 // |------------->| |
881 // | |------------->|
885 // |------------->| |
888 // | |<-------------|
891 // |<-------------| |
896 //-----------------------------------------------------------------------------
897 func TestSubReqRetransmission(t *testing.T) {
898 CaseBegin("TestSubReqRetransmission")
901 cretrans := xappConn1.SendSubsReq(t, nil, nil)
902 crereq, cremsg := e2termConn1.RecvSubsReq(t)
904 seqBef := mainCtrl.get_msgcounter(t)
905 xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq
906 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
908 // hack as there is no real way to see has message be handled.
909 // Previuos counter check just tells that is has been received by submgr
910 // --> artificial delay
911 <-time.After(1 * time.Second)
912 e2termConn1.SendSubsResp(t, crereq, cremsg)
913 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
916 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
917 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
918 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
919 xappConn1.RecvSubsDelResp(t, deltrans)
921 //Wait that subs is cleaned
922 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
924 xappConn1.TestMsgChanEmpty(t)
925 xappConn2.TestMsgChanEmpty(t)
926 e2termConn1.TestMsgChanEmpty(t)
927 mainCtrl.wait_registry_empty(t, 10)
930 //-----------------------------------------------------------------------------
931 // TestSubDelReqRetransmission
934 // +-------+ +---------+ +---------+
935 // | xapp | | submgr | | e2term |
936 // +-------+ +---------+ +---------+
942 // |------------->| |
945 // | |------------->|
950 // |------------->| |
953 // | |<-------------|
956 // |<-------------| |
958 //-----------------------------------------------------------------------------
959 func TestSubDelReqRetransmission(t *testing.T) {
960 CaseBegin("TestSubDelReqRetransmission")
963 cretrans := xappConn1.SendSubsReq(t, nil, nil)
964 crereq, cremsg := e2termConn1.RecvSubsReq(t)
965 e2termConn1.SendSubsResp(t, crereq, cremsg)
966 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
969 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
970 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
972 seqBef := mainCtrl.get_msgcounter(t)
973 xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq
974 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
976 // hack as there is no real way to see has message be handled.
977 // Previuos counter check just tells that is has been received by submgr
978 // --> artificial delay
979 <-time.After(1 * time.Second)
981 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
982 xappConn1.RecvSubsDelResp(t, deltrans)
984 //Wait that subs is cleaned
985 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
987 xappConn1.TestMsgChanEmpty(t)
988 xappConn2.TestMsgChanEmpty(t)
989 e2termConn1.TestMsgChanEmpty(t)
990 mainCtrl.wait_registry_empty(t, 10)
993 //-----------------------------------------------------------------------------
994 // TestSubDelReqCollision
997 // +-------+ +---------+ +---------+
998 // | xapp | | submgr | | e2term |
999 // +-------+ +---------+ +---------+
1001 // | [SUBS CREATE] |
1004 // | SubDelReq 1 | |
1005 // |------------->| |
1007 // | | SubDelReq 1 |
1008 // | |------------->|
1010 // | SubDelReq 2 | |
1013 // |------------->| |
1015 // | | SubDelResp 1 |
1016 // | |<-------------|
1018 // | SubDelResp 1 | |
1019 // |<-------------| |
1021 // | SubDelResp 2 | |
1022 // |<-------------| |
1024 //-----------------------------------------------------------------------------
1026 func TestSubDelReqCollision(t *testing.T) {
1027 CaseBegin("TestSubDelReqCollision")
1030 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1031 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1032 e2termConn1.SendSubsResp(t, crereq, cremsg)
1033 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1036 xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1037 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1039 // Subs Delete colliding
1040 seqBef := mainCtrl.get_msgcounter(t)
1041 deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1042 xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq
1043 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
1045 // hack as there is no real way to see has message be handled.
1046 // Previuos counter check just tells that is has been received by submgr
1047 // --> artificial delay
1048 <-time.After(1 * time.Second)
1050 // Del resp for first and second
1051 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1053 // don't care in which order responses are received
1054 xappConn1.RecvSubsDelResp(t, nil)
1055 xappConn1.RecvSubsDelResp(t, nil)
1057 //Wait that subs is cleaned
1058 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1060 xappConn1.TestMsgChanEmpty(t)
1061 xappConn2.TestMsgChanEmpty(t)
1062 e2termConn1.TestMsgChanEmpty(t)
1063 mainCtrl.wait_registry_empty(t, 10)
1066 //-----------------------------------------------------------------------------
1067 // TestSubReqAndSubDelOkTwoParallel
1070 // +-------+ +-------+ +---------+ +---------+
1071 // | xapp | | xapp | | submgr | | e2term |
1072 // +-------+ +-------+ +---------+ +---------+
1077 // | |------------->| |
1080 // | | |------------->|
1083 // |------------------------>| |
1086 // | | |------------->|
1089 // | | |<-------------|
1091 // | |<-------------| |
1094 // | | |<-------------|
1096 // |<------------------------| |
1098 // | | [SUBS 1 DELETE] |
1100 // | | [SUBS 2 DELETE] |
1103 //-----------------------------------------------------------------------------
1105 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
1106 CaseBegin("TestSubReqAndSubDelOkTwoParallel")
1109 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1111 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1112 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1115 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1118 rparams2.Req.EventTriggerDefinition.Data.Length = 1
1119 rparams2.Req.EventTriggerDefinition.Data.Data = make([]uint8, rparams2.Req.EventTriggerDefinition.Data.Length)
1120 rparams2.Req.EventTriggerDefinition.Data.Data[0] = 2
1122 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1123 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1126 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1127 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1130 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1131 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1134 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1135 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1136 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1137 xappConn1.RecvSubsDelResp(t, deltrans1)
1138 //Wait that subs is cleaned
1139 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1142 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1143 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1144 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1145 xappConn2.RecvSubsDelResp(t, deltrans2)
1146 //Wait that subs is cleaned
1147 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1149 xappConn1.TestMsgChanEmpty(t)
1150 xappConn2.TestMsgChanEmpty(t)
1151 e2termConn1.TestMsgChanEmpty(t)
1152 mainCtrl.wait_registry_empty(t, 10)
1155 //-----------------------------------------------------------------------------
1156 // TestSameSubsDiffRan
1157 // Same subscription to different RANs
1160 // +-------+ +---------+ +---------+
1161 // | xapp | | submgr | | e2term |
1162 // +-------+ +---------+ +---------+
1167 // |------------->| |
1170 // | |------------->|
1172 // | | SubResp(r1) |
1173 // | |<-------------|
1175 // | SubResp(r1) | |
1176 // |<-------------| |
1179 // |------------->| |
1182 // | |------------->|
1184 // | | SubResp(r2) |
1185 // | |<-------------|
1187 // | SubResp(r2) | |
1188 // |<-------------| |
1190 // | [SUBS r1 DELETE] |
1192 // | [SUBS r2 DELETE] |
1195 //-----------------------------------------------------------------------------
1196 func TestSameSubsDiffRan(t *testing.T) {
1197 CaseBegin("TestSameSubsDiffRan")
1200 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1201 xappConn1.SendSubsReq(t, nil, cretrans1)
1202 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1203 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1204 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1207 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
1208 xappConn1.SendSubsReq(t, nil, cretrans2)
1209 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1210 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1211 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1214 deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1215 xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
1216 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1217 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1218 xappConn1.RecvSubsDelResp(t, deltrans1)
1219 //Wait that subs is cleaned
1220 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1223 deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
1224 xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
1225 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1226 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1227 xappConn1.RecvSubsDelResp(t, deltrans2)
1228 //Wait that subs is cleaned
1229 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1231 xappConn1.TestMsgChanEmpty(t)
1232 xappConn2.TestMsgChanEmpty(t)
1233 e2termConn1.TestMsgChanEmpty(t)
1234 mainCtrl.wait_registry_empty(t, 10)
1237 //-----------------------------------------------------------------------------
1238 // TestSubReqRetryInSubmgr
1241 // +-------+ +---------+ +---------+
1242 // | xapp | | submgr | | e2term |
1243 // +-------+ +---------+ +---------+
1246 // |------------->| |
1249 // | |------------->|
1253 // | |------------->|
1256 // | |<-------------|
1259 // |<-------------| |
1261 // | [SUBS DELETE] |
1264 //-----------------------------------------------------------------------------
1266 func TestSubReqRetryInSubmgr(t *testing.T) {
1267 CaseBegin("TestSubReqRetryInSubmgr start")
1269 // Init counter check
1270 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1271 Counter{cSubReqFromXapp, 1},
1272 Counter{cSubReqToE2, 1},
1273 Counter{cSubReqTimerExpiry, 1},
1274 Counter{cSubReReqToE2, 1},
1275 Counter{cSubRespFromE2, 1},
1276 Counter{cSubRespToXapp, 1},
1277 Counter{cSubDelReqFromXapp, 1},
1278 Counter{cSubDelReqToE2, 1},
1279 Counter{cSubDelRespFromE2, 1},
1280 Counter{cSubDelRespToXapp, 1},
1283 // Xapp: Send SubsReq
1284 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1286 // E2t: Receive 1st SubsReq
1287 e2termConn1.RecvSubsReq(t)
1289 // E2t: Receive 2nd SubsReq and send SubsResp
1290 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1291 e2termConn1.SendSubsResp(t, crereq, cremsg)
1293 // Xapp: Receive SubsResp
1294 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1296 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1297 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1298 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1299 xappConn1.RecvSubsDelResp(t, deltrans)
1301 // Wait that subs is cleaned
1302 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1304 xappConn1.TestMsgChanEmpty(t)
1305 xappConn2.TestMsgChanEmpty(t)
1306 e2termConn1.TestMsgChanEmpty(t)
1307 mainCtrl.wait_registry_empty(t, 10)
1309 mainCtrl.VerifyCounterValues(t)
1312 //-----------------------------------------------------------------------------
1313 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
1316 // +-------+ +---------+ +---------+
1317 // | xapp | | submgr | | e2term |
1318 // +-------+ +---------+ +---------+
1321 // |------------->| |
1324 // | |------------->|
1328 // | |------------->|
1331 // | |------------->|
1334 // | |<-------------|
1337 //-----------------------------------------------------------------------------
1338 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
1339 CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
1341 // Init counter check
1342 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1343 Counter{cSubReqFromXapp, 1},
1344 Counter{cSubReqToE2, 1},
1345 Counter{cSubReReqToE2, 1},
1346 Counter{cSubReqTimerExpiry, 2},
1347 Counter{cSubDelReqToE2, 1},
1348 Counter{cSubDelRespFromE2, 1},
1351 // Xapp: Send SubsReq
1352 xappConn1.SendSubsReq(t, nil, nil)
1354 // E2t: Receive 1st SubsReq
1355 e2termConn1.RecvSubsReq(t)
1357 // E2t: Receive 2nd SubsReq
1358 e2termConn1.RecvSubsReq(t)
1360 // E2t: Send receive SubsDelReq and send SubsResp
1361 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1362 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1364 // Wait that subs is cleaned
1365 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 10)
1367 xappConn1.TestMsgChanEmpty(t)
1368 xappConn2.TestMsgChanEmpty(t)
1369 e2termConn1.TestMsgChanEmpty(t)
1370 mainCtrl.wait_registry_empty(t, 10)
1372 mainCtrl.VerifyCounterValues(t)
1375 //-----------------------------------------------------------------------------
1376 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
1379 // +-------+ +---------+ +---------+
1380 // | xapp | | submgr | | e2term |
1381 // +-------+ +---------+ +---------+
1384 // |------------->| |
1387 // | |------------->|
1391 // | |------------->|
1394 // | |------------->|
1398 // | |------------->|
1402 //-----------------------------------------------------------------------------
1404 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
1405 CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
1407 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1408 Counter{cSubReqFromXapp, 1},
1409 Counter{cSubReqToE2, 1},
1410 Counter{cSubReReqToE2, 1},
1411 Counter{cSubReqTimerExpiry, 2},
1412 Counter{cSubDelReqToE2, 1},
1413 Counter{cSubDelReReqToE2, 1},
1414 Counter{cSubDelReqTimerExpiry, 2},
1417 // Xapp: Send SubsReq
1418 xappConn1.SendSubsReq(t, nil, nil)
1420 // E2t: Receive 1st SubsReq
1421 e2termConn1.RecvSubsReq(t)
1423 // E2t: Receive 2nd SubsReq
1424 e2termConn1.RecvSubsReq(t)
1426 // E2t: Receive 1st SubsDelReq
1427 e2termConn1.RecvSubsDelReq(t)
1429 // E2t: Receive 2nd SubsDelReq
1430 delreq, _ := e2termConn1.RecvSubsDelReq(t)
1432 // Wait that subs is cleaned
1433 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 15)
1435 xappConn1.TestMsgChanEmpty(t)
1436 xappConn2.TestMsgChanEmpty(t)
1437 e2termConn1.TestMsgChanEmpty(t)
1438 mainCtrl.wait_registry_empty(t, 10)
1440 mainCtrl.VerifyCounterValues(t)
1443 //-----------------------------------------------------------------------------
1444 // TestSubReqSubFailRespInSubmgr
1447 // +-------+ +---------+ +---------+
1448 // | xapp | | submgr | | e2term |
1449 // +-------+ +---------+ +---------+
1452 // |------------->| |
1455 // | |------------->|
1458 // | |<-------------|
1461 // |<-------------| |
1464 //-----------------------------------------------------------------------------
1466 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1467 CaseBegin("TestSubReqSubFailRespInSubmgr start")
1469 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1470 Counter{cSubReqFromXapp, 1},
1471 Counter{cSubReqToE2, 1},
1472 Counter{cSubFailFromE2, 1},
1473 Counter{cSubFailToXapp, 1},
1476 // Xapp: Send SubsReq
1477 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1479 // E2t: Receive SubsReq and send SubsFail (first)
1480 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1481 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1482 fparams1.Set(crereq1)
1483 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1485 // Xapp: Receive SubsFail
1486 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
1488 // Wait that subs is cleaned
1489 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1491 xappConn1.TestMsgChanEmpty(t)
1492 xappConn2.TestMsgChanEmpty(t)
1493 e2termConn1.TestMsgChanEmpty(t)
1494 mainCtrl.wait_registry_empty(t, 10)
1496 mainCtrl.VerifyCounterValues(t)
1499 //-----------------------------------------------------------------------------
1500 // TestSubDelReqRetryInSubmgr
1503 // +-------+ +---------+ +---------+
1504 // | xapp | | submgr | | e2term |
1505 // +-------+ +---------+ +---------+
1507 // | [SUBS CREATE] |
1511 // |------------->| |
1514 // | |------------->|
1517 // | |------------->|
1520 // | |<-------------|
1523 // |<-------------| |
1525 //-----------------------------------------------------------------------------
1527 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1529 CaseBegin("TestSubDelReqRetryInSubmgr start")
1532 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1533 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1534 e2termConn1.SendSubsResp(t, crereq, cremsg)
1535 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1538 // Xapp: Send SubsDelReq
1539 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1541 // E2t: Receive 1st SubsDelReq
1542 e2termConn1.RecvSubsDelReq(t)
1544 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1545 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1546 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1548 // Xapp: Receive SubsDelResp
1549 xappConn1.RecvSubsDelResp(t, deltrans)
1551 // Wait that subs is cleaned
1552 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1554 xappConn1.TestMsgChanEmpty(t)
1555 xappConn2.TestMsgChanEmpty(t)
1556 e2termConn1.TestMsgChanEmpty(t)
1557 mainCtrl.wait_registry_empty(t, 10)
1560 //-----------------------------------------------------------------------------
1561 // TestSubDelReqTwoRetriesNoRespInSubmgr
1564 // +-------+ +---------+ +---------+
1565 // | xapp | | submgr | | e2term |
1566 // +-------+ +---------+ +---------+
1568 // | [SUBS CREATE] |
1572 // |------------->| |
1575 // | |------------->|
1578 // | |------------->|
1582 // |<-------------| |
1584 //-----------------------------------------------------------------------------
1586 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1588 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
1591 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1592 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1593 e2termConn1.SendSubsResp(t, crereq, cremsg)
1594 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1597 // Xapp: Send SubsDelReq
1598 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1600 // E2t: Receive 1st SubsDelReq
1601 e2termConn1.RecvSubsDelReq(t)
1603 // E2t: Receive 2nd SubsDelReq
1604 e2termConn1.RecvSubsDelReq(t)
1606 // Xapp: Receive SubsDelResp
1607 xappConn1.RecvSubsDelResp(t, deltrans)
1609 // Wait that subs is cleaned
1610 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1612 xappConn1.TestMsgChanEmpty(t)
1613 xappConn2.TestMsgChanEmpty(t)
1614 e2termConn1.TestMsgChanEmpty(t)
1615 mainCtrl.wait_registry_empty(t, 10)
1618 //-----------------------------------------------------------------------------
1619 // TestSubDelReqSubDelFailRespInSubmgr
1622 // +-------+ +---------+ +---------+
1623 // | xapp | | submgr | | e2term |
1624 // +-------+ +---------+ +---------+
1626 // | [SUBS CREATE] |
1630 // |------------->| |
1633 // | |------------->|
1636 // | |<-------------|
1639 // |<-------------| |
1642 //-----------------------------------------------------------------------------
1644 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1645 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1647 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1648 Counter{cSubReqFromXapp, 1},
1649 Counter{cSubReqToE2, 1},
1650 Counter{cSubRespFromE2, 1},
1651 Counter{cSubRespToXapp, 1},
1652 Counter{cSubDelReqFromXapp, 1},
1653 Counter{cSubDelReqToE2, 1},
1654 Counter{cSubDelFailFromE2, 1},
1655 Counter{cSubDelRespToXapp, 1},
1659 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1660 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1661 e2termConn1.SendSubsResp(t, crereq, cremsg)
1662 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1664 // Xapp: Send SubsDelReq
1665 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1667 // E2t: Send receive SubsDelReq and send SubsDelFail
1668 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1669 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1671 // Xapp: Receive SubsDelResp
1672 xappConn1.RecvSubsDelResp(t, deltrans)
1674 // Wait that subs is cleaned
1675 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1677 xappConn1.TestMsgChanEmpty(t)
1678 xappConn2.TestMsgChanEmpty(t)
1679 e2termConn1.TestMsgChanEmpty(t)
1680 mainCtrl.wait_registry_empty(t, 10)
1682 mainCtrl.VerifyCounterValues(t)
1685 //-----------------------------------------------------------------------------
1686 // TestSubReqAndSubDelOkSameAction
1689 // +-------+ +-------+ +---------+ +---------+
1690 // | xapp2 | | xapp1 | | submgr | | e2term |
1691 // +-------+ +-------+ +---------+ +---------+
1696 // | |------------->| |
1699 // | | |------------->|
1701 // | | |<-------------|
1703 // | |<-------------| |
1706 // |--------------------------->| |
1709 // |<---------------------------| |
1711 // | | SubDelReq 1 | |
1712 // | |------------->| |
1714 // | | SubDelResp 1 | |
1715 // | |<-------------| |
1717 // | SubDelReq 2 | |
1718 // |--------------------------->| |
1720 // | | | SubDelReq 2 |
1721 // | | |------------->|
1723 // | | | SubDelReq 2 |
1724 // | | |------------->|
1726 // | SubDelResp 2 | |
1727 // |<---------------------------| |
1729 //-----------------------------------------------------------------------------
1730 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
1731 CaseBegin("TestSubReqAndSubDelOkSameAction")
1733 // Init counter check
1734 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1735 Counter{cSubReqFromXapp, 2},
1736 Counter{cSubReqToE2, 1},
1737 Counter{cSubRespFromE2, 1},
1738 Counter{cSubRespToXapp, 2},
1739 Counter{cMergedSubscriptions, 1},
1740 Counter{cUnmergedSubscriptions, 1},
1741 Counter{cSubDelReqFromXapp, 2},
1742 Counter{cSubDelReqToE2, 1},
1743 Counter{cSubDelRespFromE2, 1},
1744 Counter{cSubDelRespToXapp, 2},
1748 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1750 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1751 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1752 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1753 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1756 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1758 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1759 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1761 resp, _ := xapp.Subscription.QuerySubscriptions()
1762 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1763 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1764 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
1767 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1768 xappConn1.RecvSubsDelResp(t, deltrans1)
1771 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1772 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1773 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1774 xappConn2.RecvSubsDelResp(t, deltrans2)
1775 //Wait that subs is cleaned
1776 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1778 xappConn1.TestMsgChanEmpty(t)
1779 xappConn2.TestMsgChanEmpty(t)
1780 e2termConn1.TestMsgChanEmpty(t)
1781 mainCtrl.wait_registry_empty(t, 10)
1783 mainCtrl.VerifyCounterValues(t)
1786 //-----------------------------------------------------------------------------
1787 // TestSubReqAndSubDelOkSameActionParallel
1790 // +-------+ +-------+ +---------+ +---------+
1791 // | xapp2 | | xapp1 | | submgr | | e2term |
1792 // +-------+ +-------+ +---------+ +---------+
1797 // | |------------->| |
1800 // | | |------------->|
1802 // |--------------------------->| |
1804 // | | |<-------------|
1806 // | |<-------------| |
1809 // |<---------------------------| |
1811 // | | SubDelReq 1 | |
1812 // | |------------->| |
1814 // | | SubDelResp 1 | |
1815 // | |<-------------| |
1817 // | SubDelReq 2 | |
1818 // |--------------------------->| |
1820 // | | | SubDelReq 2 |
1821 // | | |------------->|
1823 // | | | SubDelReq 2 |
1824 // | | |------------->|
1826 // | SubDelResp 2 | |
1827 // |<---------------------------| |
1829 //-----------------------------------------------------------------------------
1830 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1831 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1834 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1836 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1837 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1840 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1842 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1845 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1846 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1849 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1852 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1853 xappConn1.RecvSubsDelResp(t, deltrans1)
1856 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1857 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1858 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1859 xappConn2.RecvSubsDelResp(t, deltrans2)
1861 //Wait that subs is cleaned
1862 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1864 xappConn1.TestMsgChanEmpty(t)
1865 xappConn2.TestMsgChanEmpty(t)
1866 e2termConn1.TestMsgChanEmpty(t)
1867 mainCtrl.wait_registry_empty(t, 10)
1870 //-----------------------------------------------------------------------------
1871 // TestSubReqAndSubDelNokSameActionParallel
1874 // +-------+ +-------+ +---------+ +---------+
1875 // | xapp2 | | xapp1 | | submgr | | e2term |
1876 // +-------+ +-------+ +---------+ +---------+
1881 // | |------------->| |
1884 // | | |------------->|
1886 // |--------------------------->| |
1888 // | | |<-------------|
1891 // | |<-------------| |
1894 // |<---------------------------| |
1896 //-----------------------------------------------------------------------------
1897 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1898 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1901 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1903 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1905 // E2t: Receive SubsReq (first)
1906 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1909 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1911 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1912 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1913 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1915 // E2t: send SubsFail (first)
1916 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1917 fparams1.Set(crereq1)
1918 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1921 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1923 xappConn2.RecvSubsFail(t, cretrans2)
1925 //Wait that subs is cleaned
1926 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1928 xappConn1.TestMsgChanEmpty(t)
1929 xappConn2.TestMsgChanEmpty(t)
1930 e2termConn1.TestMsgChanEmpty(t)
1931 mainCtrl.wait_registry_empty(t, 10)
1934 //-----------------------------------------------------------------------------
1935 // TestSubReqAndSubDelNoAnswerSameActionParallel
1938 // +-------+ +-------+ +---------+ +---------+
1939 // | xapp2 | | xapp1 | | submgr | | e2term |
1940 // +-------+ +-------+ +---------+ +---------+
1945 // | |------------->| |
1948 // | | |------------->|
1950 // |--------------------------->| |
1953 // | | |------------->|
1956 // | | | SubDelReq |
1957 // | | |------------->|
1959 // | | | SubDelResp |
1960 // | | |<-------------|
1962 //-----------------------------------------------------------------------------
1963 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1964 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1967 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1969 xappConn1.SendSubsReq(t, rparams1, nil)
1971 crereq1, _ := e2termConn1.RecvSubsReq(t)
1974 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1976 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1977 xappConn2.SendSubsReq(t, rparams2, nil)
1978 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1980 //Req1 (retransmitted)
1981 e2termConn1.RecvSubsReq(t)
1983 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1984 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1986 //Wait that subs is cleaned
1987 mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10)
1989 xappConn1.TestMsgChanEmpty(t)
1990 xappConn2.TestMsgChanEmpty(t)
1991 e2termConn1.TestMsgChanEmpty(t)
1992 mainCtrl.wait_registry_empty(t, 15)
1995 //----------------------------- Policy cases ---------------------------------
1996 //-----------------------------------------------------------------------------
1997 // TestSubReqPolicyAndSubDelOk
2000 // +-------+ +---------+ +---------+
2001 // | xapp | | submgr | | e2term |
2002 // +-------+ +---------+ +---------+
2005 // |------------->| |
2008 // | |------------->|
2011 // | |<-------------|
2014 // |<-------------| |
2018 // |------------->| |
2021 // | |------------->|
2024 // | |<-------------|
2027 // |<-------------| |
2029 //-----------------------------------------------------------------------------
2030 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
2031 CaseBegin("TestSubReqAndSubDelOk")
2033 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2035 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
2036 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2038 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2039 e2termConn1.SendSubsResp(t, crereq, cremsg)
2040 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2041 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2042 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2044 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2045 xappConn1.RecvSubsDelResp(t, deltrans)
2047 //Wait that subs is cleaned
2048 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2050 xappConn1.TestMsgChanEmpty(t)
2051 xappConn2.TestMsgChanEmpty(t)
2052 e2termConn1.TestMsgChanEmpty(t)
2053 mainCtrl.wait_registry_empty(t, 10)
2056 //-----------------------------------------------------------------------------
2057 // TestSubReqPolicyChangeAndSubDelOk
2060 // +-------+ +---------+ +---------+
2061 // | xapp | | submgr | | e2term |
2062 // +-------+ +---------+ +---------+
2065 // |------------->| |
2068 // | |------------->|
2071 // | |<-------------|
2074 // |<-------------| |
2077 // |------------->| |
2080 // | |------------->|
2083 // | |<-------------|
2086 // |<-------------| |
2089 // |------------->| |
2092 // | |------------->|
2095 // | |<-------------|
2098 // |<-------------| |
2100 //-----------------------------------------------------------------------------
2102 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
2103 CaseBegin("TestSubReqAndSubDelOk")
2105 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2107 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
2108 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2110 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2111 e2termConn1.SendSubsResp(t, crereq, cremsg)
2112 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2115 rparams1.Req.RequestId.InstanceId = e2SubsId
2116 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
2117 xappConn1.SendSubsReq(t, rparams1, cretrans)
2119 crereq, cremsg = e2termConn1.RecvSubsReq(t)
2120 e2termConn1.SendSubsResp(t, crereq, cremsg)
2121 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2122 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2123 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2125 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2126 xappConn1.RecvSubsDelResp(t, deltrans)
2128 //Wait that subs is cleaned
2129 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2131 xappConn1.TestMsgChanEmpty(t)
2132 xappConn2.TestMsgChanEmpty(t)
2133 e2termConn1.TestMsgChanEmpty(t)
2134 mainCtrl.wait_registry_empty(t, 10)
2137 //-----------------------------------------------------------------------------
2138 // TestSubReqAndSubDelOkTwoE2termParallel
2141 // +-------+ +---------+ +---------+ +---------+
2142 // | xapp | | submgr | | e2term1 | | e2term2 |
2143 // +-------+ +---------+ +---------+ +---------+
2148 // |------------->| | |
2151 // | |------------->| |
2154 // |------------->| | |
2157 // | |---------------------------->|
2160 // | |<-------------| |
2162 // |<-------------| | |
2164 // | |<----------------------------|
2166 // |<-------------| | |
2168 // | [SUBS 1 DELETE] | |
2170 // | [SUBS 2 DELETE] | |
2173 //-----------------------------------------------------------------------------
2174 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
2175 CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
2178 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
2179 xappConn1.SendSubsReq(t, nil, cretrans1)
2180 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2182 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
2183 xappConn1.SendSubsReq(t, nil, cretrans2)
2184 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
2187 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2188 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2191 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
2192 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
2195 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2196 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2197 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2198 xappConn1.RecvSubsDelResp(t, deltrans1)
2199 //Wait that subs is cleaned
2200 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
2203 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
2204 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
2205 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
2206 xappConn1.RecvSubsDelResp(t, deltrans2)
2207 //Wait that subs is cleaned
2208 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2210 xappConn1.TestMsgChanEmpty(t)
2211 xappConn2.TestMsgChanEmpty(t)
2212 e2termConn1.TestMsgChanEmpty(t)
2213 e2termConn2.TestMsgChanEmpty(t)
2214 mainCtrl.wait_registry_empty(t, 10)
2217 //-----------------------------------------------------------------------------
2218 // TestSubReqInsertAndSubDelOk
2221 // +-------+ +---------+ +---------+
2222 // | xapp | | submgr | | e2term |
2223 // +-------+ +---------+ +---------+
2226 // |------------->| |
2229 // | |------------->|
2232 // | |<-------------|
2235 // |<-------------| |
2239 // |------------->| |
2242 // | |------------->|
2245 // | |<-------------|
2248 // |<-------------| |
2250 //-----------------------------------------------------------------------------
2251 func TestSubReqInsertAndSubDelOk(t *testing.T) {
2252 CaseBegin("TestInsertSubReqAndSubDelOk")
2254 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2256 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeInsert
2257 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2259 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2260 e2termConn1.SendSubsResp(t, crereq, cremsg)
2261 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2262 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2263 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2265 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2266 xappConn1.RecvSubsDelResp(t, deltrans)
2268 //Wait that subs is cleaned
2269 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2271 xappConn1.TestMsgChanEmpty(t)
2272 xappConn2.TestMsgChanEmpty(t)
2273 e2termConn1.TestMsgChanEmpty(t)
2274 mainCtrl.wait_registry_empty(t, 10)
2277 //-----------------------------------------------------------------------------
2278 // TestSubReqRetransmissionWithSameSubIdDiffXid
2280 // This case simulates case where xApp restarts and starts sending same
2281 // subscription requests which have already subscribed successfully
2284 // +-------+ +---------+ +---------+
2285 // | xapp | | submgr | | e2term |
2286 // +-------+ +---------+ +---------+
2289 // |------------->| |
2292 // | |------------->|
2295 // | |<-------------|
2298 // |<-------------| |
2300 // | xApp restart | |
2303 // | (retrans with same xApp generated subid but diff xid)
2304 // |------------->| |
2307 // |<-------------| |
2309 // | [SUBS DELETE] |
2312 //-----------------------------------------------------------------------------
2313 func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) {
2314 CaseBegin("TestSubReqRetransmissionWithSameSubIdDiffXid")
2317 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2318 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2319 e2termConn1.SendSubsResp(t, crereq, cremsg)
2320 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2322 // xApp restart here
2323 // --> artificial delay
2324 <-time.After(1 * time.Second)
2327 cretrans = xappConn1.SendSubsReq(t, nil, nil) //Retransmitted SubReq
2328 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2331 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2332 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2333 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2334 xappConn1.RecvSubsDelResp(t, deltrans)
2336 //Wait that subs is cleaned
2337 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2339 xappConn1.TestMsgChanEmpty(t)
2340 xappConn2.TestMsgChanEmpty(t)
2341 e2termConn1.TestMsgChanEmpty(t)
2342 mainCtrl.wait_registry_empty(t, 10)
2345 //-----------------------------------------------------------------------------
2346 // TestSubReqNokAndSubDelOkWithRestartInMiddle
2349 // +-------+ +---------+ +---------+
2350 // | xapp | | submgr | | e2term |
2351 // +-------+ +---------+ +---------+
2354 // |------------->| |
2357 // | |------------->|
2362 // | Submgr restart |
2366 // | |------------->|
2369 // | |<-------------|
2372 //-----------------------------------------------------------------------------
2374 func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
2375 CaseBegin("TestSubReqNokAndSubDelOkWithRestartInMiddle")
2377 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
2378 xappConn1.SendSubsReq(t, nil, nil)
2379 e2termConn1.RecvSubsReq(t)
2380 mainCtrl.SetResetTestFlag(t, false)
2382 resp, _ := xapp.Subscription.QuerySubscriptions()
2383 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2384 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2385 e2SubsId := uint32(resp[0].SubscriptionID)
2386 t.Logf("e2SubsId = %v", e2SubsId)
2388 mainCtrl.SimulateRestart(t)
2389 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2391 // Submgr send delete for uncompleted subscription
2392 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2393 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2395 // Wait that subs is cleaned
2396 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2398 xappConn1.TestMsgChanEmpty(t)
2399 xappConn2.TestMsgChanEmpty(t)
2400 e2termConn1.TestMsgChanEmpty(t)
2401 mainCtrl.wait_registry_empty(t, 10)
2404 //-----------------------------------------------------------------------------
2405 // TestSubReqAndSubDelOkWithRestartInMiddle
2408 // +-------+ +---------+ +---------+
2409 // | xapp | | submgr | | e2term |
2410 // +-------+ +---------+ +---------+
2413 // |------------->| |
2416 // | |------------->|
2419 // | |<-------------|
2422 // |<-------------| |
2425 // | Submgr restart |
2428 // |------------->| |
2431 // | |------------->|
2434 // | |<-------------|
2437 // |<-------------| |
2439 //-----------------------------------------------------------------------------
2441 func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
2442 CaseBegin("TestSubReqAndSubDelOkWithRestartInMiddle")
2444 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2445 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2446 e2termConn1.SendSubsResp(t, crereq, cremsg)
2447 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2449 // Check subscription
2450 resp, _ := xapp.Subscription.QuerySubscriptions()
2451 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2452 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2453 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2455 mainCtrl.SimulateRestart(t)
2456 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2458 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
2459 // That needs to be completed before successful subscription query is possible
2460 <-time.After(time.Second * 1)
2462 // Check that subscription is restored correctly after restart
2463 resp, _ = xapp.Subscription.QuerySubscriptions()
2464 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2465 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2466 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2468 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2469 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2470 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2471 xappConn1.RecvSubsDelResp(t, deltrans)
2473 //Wait that subs is cleaned
2474 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2476 xappConn1.TestMsgChanEmpty(t)
2477 xappConn2.TestMsgChanEmpty(t)
2478 e2termConn1.TestMsgChanEmpty(t)
2479 mainCtrl.wait_registry_empty(t, 10)
2482 //-----------------------------------------------------------------------------
2483 // TestSubReqAndSubDelOkSameActionWithRestartsInMiddle
2486 // +-------+ +-------+ +---------+ +---------+
2487 // | xapp2 | | xapp1 | | submgr | | e2term |
2488 // +-------+ +-------+ +---------+ +---------+
2493 // | |------------->| |
2496 // | | |------------->|
2498 // | | |<-------------|
2500 // | |<-------------| |
2503 // | submgr restart |
2508 // |--------------------------->| |
2511 // |<---------------------------| |
2513 // | | SubDelReq 1 | |
2514 // | |------------->| |
2516 // | | SubDelResp 1 | |
2517 // | |<-------------| |
2521 // | submgr restart |
2524 // | SubDelReq 2 | |
2525 // |--------------------------->| |
2527 // | | | SubDelReq 2 |
2528 // | | |------------->|
2530 // | | | SubDelReq 2 |
2531 // | | |------------->|
2533 // | SubDelResp 2 | |
2534 // |<---------------------------| |
2536 //-----------------------------------------------------------------------------
2538 func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
2539 CaseBegin("TestSubReqAndSubDelOkSameActionWithRestartsInMiddle")
2542 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2544 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2545 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2546 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2547 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2550 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2552 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2553 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
2555 // Check subscription
2556 resp, _ := xapp.Subscription.QuerySubscriptions()
2557 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2558 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2559 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2561 mainCtrl.SimulateRestart(t)
2562 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2564 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
2565 // That needs to be completed before successful subscription query is possible
2566 <-time.After(time.Second * 1)
2568 // Check that subscription is restored correctly after restart
2569 resp, _ = xapp.Subscription.QuerySubscriptions()
2570 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2571 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2572 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2575 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2576 xapp.Logger.Debug("xappConn1.RecvSubsDelResp")
2577 xappConn1.RecvSubsDelResp(t, deltrans1)
2578 xapp.Logger.Debug("xappConn1.RecvSubsDelResp received")
2580 mainCtrl.SimulateRestart(t)
2581 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2583 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
2584 // Submgr need be ready before successful subscription deletion is possible
2585 <-time.After(time.Second * 1)
2588 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
2589 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2591 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2592 xappConn2.RecvSubsDelResp(t, deltrans2)
2594 //Wait that subs is cleaned
2595 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2597 xappConn1.TestMsgChanEmpty(t)
2598 xappConn2.TestMsgChanEmpty(t)
2599 e2termConn1.TestMsgChanEmpty(t)
2600 mainCtrl.wait_registry_empty(t, 10)
2603 //*****************************************************************************
2604 // REST interface test cases
2605 //*****************************************************************************
2607 //-----------------------------------------------------------------------------
2608 // Test debug GET and POST requests
2611 // +-------+ +---------+
2612 // | user | | submgr |
2613 // +-------+ +---------+
2620 func TestGetSubscriptions(t *testing.T) {
2622 mainCtrl.sendGetRequest(t, "localhost:8088", "/ric/v1/subscriptions")
2625 func TestGetSymptomData(t *testing.T) {
2627 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/symptomdata")
2630 func TestPostdeleteSubId(t *testing.T) {
2632 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/deletesubid=1")
2635 func TestPostEmptyDb(t *testing.T) {
2637 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/emptydb")
2640 func TestGetRestSubscriptions(t *testing.T) {
2642 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/restsubscriptions")
2645 //-----------------------------------------------------------------------------
2646 // TestRESTSubReqAndRouteNok
2649 // +-------+ +---------+ +---------+
2650 // | xapp | | submgr | | rtmgr |
2651 // +-------+ +---------+ +---------+
2654 // |---------------->| |
2656 // | RESTSubResp | |
2657 // |<----------------| |
2658 // | | RouteCreate |
2659 // | |------------->|
2661 // | | RouteCreate |
2663 // | |(Bad request) |
2664 // | |<-------------|
2666 // |<----------------| |
2668 // | [SUBS INT DELETE] |
2670 // | RESTSubDelReq | |
2671 // |---------------->| |
2672 // | RESTSubDelResp | |
2673 // |<----------------| |
2675 //-----------------------------------------------------------------------------
2676 func TestRESTSubReqAndRouteNok(t *testing.T) {
2677 CaseBegin("TestRESTSubReqAndRouteNok")
2679 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2680 Counter{cRestSubReqFromXapp, 1},
2681 Counter{cRestSubRespToXapp, 1},
2682 Counter{cRouteCreateFail, 1},
2683 Counter{cRestSubFailNotifToXapp, 1},
2684 Counter{cRestSubDelReqFromXapp, 1},
2685 Counter{cRestSubDelRespToXapp, 1},
2688 const subReqCount int = 1
2690 // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
2691 waiter := rtmgrHttp.AllocNextSleep(50, false)
2692 newSubsId := mainCtrl.get_registry_next_subid(t)
2695 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2696 restSubId := xappConn1.SendRESTSubsReq(t, params)
2697 xappConn1.ExpectRESTNotificationNok(t, restSubId, "failAll")
2698 waiter.WaitResult(t)
2700 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2701 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
2704 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2706 // Wait that subs is cleaned
2707 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2708 waitSubsCleanup(t, e2SubsId, 10)
2709 mainCtrl.VerifyCounterValues(t)
2710 mainCtrl.VerifyAllClean(t)
2713 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
2714 CaseBegin("TestSubReqAndRouteUpdateNok")
2716 //Init counter check
2717 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2718 Counter{cRestSubReqFromXapp, 2},
2719 Counter{cRestSubRespToXapp, 2},
2720 Counter{cSubReqToE2, 1},
2721 Counter{cSubRespFromE2, 1},
2722 Counter{cRestSubNotifToXapp, 1},
2723 Counter{cRestSubFailNotifToXapp, 1},
2724 Counter{cRouteCreateUpdateFail, 1},
2725 Counter{cRestSubDelReqFromXapp, 2},
2726 Counter{cSubDelReqToE2, 1},
2727 Counter{cSubDelRespFromE2, 1},
2728 Counter{cRestSubDelRespToXapp, 2},
2731 var params *teststube2ap.RESTSubsReqParams = nil
2734 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2736 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2738 // xapp2 ROUTE creation shall fail with 400 from rtmgr -> submgr
2739 waiter := rtmgrHttp.AllocNextEvent(false)
2740 newSubsId := mainCtrl.get_registry_next_subid(t)
2741 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
2742 params.SetMeid("RAN_NAME_1")
2743 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2744 xapp.Logger.Debug("Send REST subscriber request for second subscriber : %v", restSubId2)
2745 xappConn2.ExpectRESTNotificationNok(t, restSubId2, "allFail")
2746 waiter.WaitResult(t)
2747 xappConn2.WaitRESTNotification(t, restSubId2)
2749 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2751 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2752 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
2754 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2755 //Wait that subs is cleaned
2756 waitSubsCleanup(t, e2SubsId, 10)
2758 mainCtrl.VerifyCounterValues(t)
2759 mainCtrl.VerifyAllClean(t)
2762 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
2763 CaseBegin("TestRESTSubDelReqAndRouteDeleteNok")
2765 // Init counter check
2766 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2767 Counter{cRestSubReqFromXapp, 1},
2768 Counter{cRestSubRespToXapp, 1},
2769 Counter{cSubReqToE2, 1},
2770 Counter{cSubRespFromE2, 1},
2771 Counter{cRestSubNotifToXapp, 1},
2772 Counter{cRestSubDelReqFromXapp, 1},
2773 Counter{cRouteDeleteFail, 1},
2774 Counter{cSubDelReqToE2, 1},
2775 Counter{cSubDelRespFromE2, 1},
2776 Counter{cRestSubDelRespToXapp, 1},
2779 var params *teststube2ap.RESTSubsReqParams = nil
2782 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2784 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2786 waiter := rtmgrHttp.AllocNextEvent(false)
2787 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2788 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2789 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2790 waiter.WaitResult(t)
2792 waitSubsCleanup(t, e2SubsId, 10)
2793 mainCtrl.VerifyCounterValues(t)
2794 mainCtrl.VerifyAllClean(t)
2797 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
2798 CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok")
2800 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2801 Counter{cRestSubReqFromXapp, 2},
2802 Counter{cMergedSubscriptions, 1},
2803 Counter{cRestSubRespToXapp, 2},
2804 Counter{cSubReqToE2, 1},
2805 Counter{cSubRespFromE2, 1},
2806 Counter{cRestSubNotifToXapp, 2},
2807 Counter{cRestSubDelReqFromXapp, 2},
2808 Counter{cRouteDeleteUpdateFail, 1},
2809 Counter{cSubDelReqToE2, 1},
2810 Counter{cSubDelRespFromE2, 1},
2811 Counter{cRestSubDelRespToXapp, 2},
2812 Counter{cUnmergedSubscriptions, 1},
2815 var params *teststube2ap.RESTSubsReqParams = nil
2818 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2820 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2821 restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1")
2823 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
2825 //Del1, this shall fail on rtmgr side
2826 waiter := rtmgrHttp.AllocNextEvent(false)
2827 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2828 waiter.WaitResult(t)
2830 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"})
2833 deleteXapp2Subscription(t, &restSubId2)
2835 waitSubsCleanup(t, e2SubsId2, 10)
2836 mainCtrl.VerifyCounterValues(t)
2837 mainCtrl.VerifyAllClean(t)
2840 //-----------------------------------------------------------------------------
2841 // TestRESTSubReqRetransmission
2844 // +-------+ +---------+ +---------+
2845 // | xapp | | submgr | | e2term |
2846 // +-------+ +---------+ +---------+
2848 // | RESTSubReq1 | |
2849 // |---------------->| |
2851 // | RESTSubResp | |
2852 // |<----------------| |
2854 // | |------------->|
2856 // | RESTSubReq2 | |
2858 // |---------------->| |
2859 // | RESTSubResp(201)| |
2860 // |<----------------| |
2863 // | |<-------------|
2865 // |<----------------| |
2867 // | [SUBS DELETE] |
2870 //-----------------------------------------------------------------------------
2872 func TestRESTSubReqRetransmission(t *testing.T) {
2873 CaseBegin("TestRESTSubReqRetransmission")
2875 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2876 Counter{cRestSubReqFromXapp, 2},
2877 Counter{cRestSubRespToXapp, 2},
2878 Counter{cSubReqToE2, 1},
2879 Counter{cSubRespFromE2, 1},
2880 Counter{cRestSubNotifToXapp, 1},
2881 Counter{cRestSubDelReqFromXapp, 1},
2882 Counter{cSubDelReqToE2, 1},
2883 Counter{cSubDelRespFromE2, 1},
2884 Counter{cRestSubDelRespToXapp, 1},
2886 // Retry/duplicate will get the same way as the first request.
2887 // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
2888 // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
2891 const subReqCount int = 1
2893 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2894 restSubId := xappConn1.SendRESTSubsReq(t, params)
2896 xappConn1.SendRESTSubsReq(t, params)
2897 <-time.After(time.Second * 1)
2899 xappConn1.WaitListedRestNotifications(t, []string{restSubId})
2901 // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
2902 // the order is not significant here.
2903 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2904 e2termConn1.SendSubsResp(t, crereq, cremsg)
2906 e2SubsId := <-xappConn1.ListedRESTNotifications
2908 xapp.Logger.Debug("TEST: XAPP notification received e2SubsId=%v", e2SubsId)
2911 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2912 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2913 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2915 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsId.E2SubsId}, 10)
2917 mainCtrl.VerifyCounterValues(t)
2918 mainCtrl.VerifyAllClean(t)
2921 //-----------------------------------------------------------------------------
2923 // +-------+ +---------+ +---------+ +---------+
2924 // | xapp | | submgr | | e2term | | rtmgr |
2925 // +-------+ +---------+ +---------+ +---------+
2927 // | RESTSubReq | | |
2928 // |---------------->| | |
2929 // | RESTSubResp | | |
2930 // |<----------------| | |
2931 // | | RouteCreate | |
2932 // | |--------------------------->|
2933 // | | RouteResponse| |
2934 // | |<---------------------------| // The order of these events may vary
2936 // | |------------->| | // The order of these events may vary
2938 // | |<-------------| |
2939 // | RESTNotif1 | | |
2940 // |<----------------| | |
2941 // | RESTSubReq | | |
2942 // | [RETRANS1] | | |
2943 // |---------------->| | |
2944 // | RESTNotif1 | | |
2945 // |<----------------| | |
2946 // | RESTSubReq | | |
2947 // | [RETRANS2] | | |
2948 // |---------------->| | |
2949 // | RESTNotif1 | | |
2950 // |<----------------| | |
2951 // | RESTSubDelReq | | |
2952 // |---------------->| | |
2953 // | | SubDelReq | |
2954 // | |------------->| |
2955 // | RESTSubDelResp| | |
2956 // |<----------------| | |
2957 // | | SubDelResp | |
2958 // | |<-------------| |
2961 //-----------------------------------------------------------------------------
2963 func TestRESTSubReqRetransmissionV2(t *testing.T) {
2964 CaseBegin("TestRESTSubReqRetransmissionV2")
2966 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2967 Counter{cRestSubReqFromXapp, 3},
2968 Counter{cDuplicateE2SubReq, 2},
2969 Counter{cRestSubRespToXapp, 3},
2970 Counter{cSubReqToE2, 1},
2971 Counter{cSubRespFromE2, 1},
2972 Counter{cRestSubNotifToXapp, 3},
2973 Counter{cRestSubDelReqFromXapp, 1},
2974 Counter{cSubDelReqToE2, 1},
2975 Counter{cSubDelRespFromE2, 1},
2976 Counter{cRestSubDelRespToXapp, 1},
2979 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2981 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2983 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2985 mainCtrl.WaitOngoingRequestMapEmpty()
2988 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
2990 assert.Equal(t, restSubId_resend, restSubId)
2992 mainCtrl.WaitOngoingRequestMapEmpty()
2995 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
2997 assert.Equal(t, restSubId_resend2, restSubId)
2999 mainCtrl.WaitOngoingRequestMapEmpty()
3001 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3003 waitSubsCleanup(t, e2SubsId, 10)
3004 mainCtrl.VerifyCounterValues(t)
3005 mainCtrl.VerifyAllClean(t)
3008 //-----------------------------------------------------------------------------
3010 // +-------+ +---------+ +---------+ +---------+
3011 // | xapp | | submgr | | e2term | | rtmgr |
3012 // +-------+ +---------+ +---------+ +---------+
3014 // | RESTSubReq | | |
3015 // |---------------->| | |
3016 // | RESTSubResp | | |
3017 // |<----------------| | |
3018 // | | RouteCreate | |
3019 // | |--------------------------->|
3020 // | | RouteResponse| |
3021 // | |<---------------------------| // The order of these events may vary
3023 // | |------------->| | // The order of these events may vary
3025 // | |<-------------| |
3026 // | RESTNotif1 | | |
3027 // |<----------------| | |
3028 // | RESTSubReq | | |
3029 // | [RETRANS, with RESTsubsId] | |
3030 // |---------------->| | |
3031 // | RESTNotif1 | | |
3032 // |<----------------| | |
3033 // | RESTSubReq | | |
3034 // | [RETRANS, without RESTsubsId] | |
3035 // |---------------->| | |
3036 // | RESTNotif1 | | |
3037 // |<----------------| | |
3038 // | RESTSubDelReq | | |
3039 // |---------------->| | |
3040 // | | SubDelReq | |
3041 // | |------------->| |
3042 // | RESTSubDelResp| | |
3043 // |<----------------| | |
3044 // | | SubDelResp | |
3045 // | |<-------------| |
3048 //-----------------------------------------------------------------------------
3049 func TestRESTSubReqRetransmissionV3(t *testing.T) {
3050 CaseBegin("TestRESTSubReqRetransmissionV3")
3052 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3053 Counter{cRestSubReqFromXapp, 3},
3054 Counter{cDuplicateE2SubReq, 2},
3055 Counter{cRestSubRespToXapp, 3},
3056 Counter{cSubReqToE2, 1},
3057 Counter{cSubRespFromE2, 1},
3058 Counter{cRestSubNotifToXapp, 3},
3059 Counter{cRestSubDelReqFromXapp, 1},
3060 Counter{cSubDelReqToE2, 1},
3061 Counter{cSubDelRespFromE2, 1},
3062 Counter{cRestSubDelRespToXapp, 1},
3065 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3067 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3069 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3071 mainCtrl.WaitOngoingRequestMapEmpty()
3073 //1.st resend with subscription ID
3074 params.SetSubscriptionID(&restSubId)
3075 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
3077 assert.Equal(t, restSubId_resend, restSubId)
3079 mainCtrl.WaitOngoingRequestMapEmpty()
3081 //2.nd resend without subscription ID (faking app restart)
3082 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3083 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3085 assert.Equal(t, restSubId_resend2, restSubId)
3087 mainCtrl.WaitOngoingRequestMapEmpty()
3089 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3091 waitSubsCleanup(t, e2SubsId, 10)
3092 mainCtrl.VerifyCounterValues(t)
3093 mainCtrl.VerifyAllClean(t)
3096 //-----------------------------------------------------------------------------
3098 // +-------+ +---------+ +---------+ +---------+
3099 // | xapp | | submgr | | e2term | | rtmgr |
3100 // +-------+ +---------+ +---------+ +---------+
3102 // | RESTSubReq | | |
3103 // |---------------->| | |
3104 // | RESTSubResp | | |
3105 // |<----------------| | |
3106 // | | RouteCreate | |
3107 // | |--------------------------->|
3108 // | | RouteResponse| |
3109 // | |<---------------------------|
3111 // | |------------->| |
3113 // | |<-------------| |
3114 // | RESTNotif1 | | |
3115 // |<----------------| | |
3116 // | RESTSubReq | | |
3117 // | [with RestSUbsId + one additional e2 subDetail]
3118 // |---------------->| | |
3119 // | RESTNotif1 | | |
3120 // | [for initial e2 subDetail] | |
3121 // |<----------------| | |
3122 // | | RouteCreate | |
3123 // | |--------------------------->|
3124 // | | RouteResponse| |
3125 // | |<---------------------------|
3127 // | |------------->| |
3129 // | |<-------------| |
3130 // | RESTNotif1 | | |
3131 // |<----------------| | |
3132 // | RESTSubReq | | |
3133 // | [with RESTsubsId initial request] |
3134 // |---------------->| | |
3135 // | RESTNotif1 | | |
3136 // |<----------------| | |
3137 // | RESTSubDelReq | | |
3138 // |---------------->| | |
3139 // | RESTSubDelResp| | |
3140 // |<----------------| | |
3141 // | | SubDelReq | |
3142 // | |------------->| |
3143 // | | SubDelResp | |
3144 // | |<-------------| |
3145 // | | SubDelReq | |
3146 // | |------------->| |
3147 // | | SubDelResp | |
3148 // | |<-------------| |
3151 //-----------------------------------------------------------------------------
3153 func TestRESTSubReqRetransmissionV4(t *testing.T) {
3154 CaseBegin("TestRESTSubReqRetransmissionV4")
3156 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3157 Counter{cRestSubReqFromXapp, 3},
3158 Counter{cDuplicateE2SubReq, 2},
3159 Counter{cRestSubRespToXapp, 3},
3160 Counter{cSubReqToE2, 2},
3161 Counter{cSubRespFromE2, 2},
3162 Counter{cRestSubNotifToXapp, 4},
3163 Counter{cRestSubDelReqFromXapp, 1},
3164 Counter{cSubDelReqToE2, 2},
3165 Counter{cSubDelRespFromE2, 2},
3166 Counter{cRestSubDelRespToXapp, 1},
3169 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3171 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3173 mainCtrl.WaitOngoingRequestMapEmpty()
3175 // Send modified requst, this time with e2 subscriptions.
3176 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3177 params2.SetSubscriptionID(&restSubId)
3179 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3180 xappConn1.ExpectAnyNotification(t)
3181 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3182 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3183 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3184 assert.Equal(t, e2SubsId, e2SubsId1)
3186 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3188 xappConn1.DecrementRequestCount()
3189 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3190 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3191 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3192 assert.NotEqual(t, e2SubsId2, 0)
3194 mainCtrl.WaitOngoingRequestMapEmpty()
3196 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3197 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3198 params.SetSubscriptionID(&restSubId)
3199 xappConn1.ExpectAnyNotification(t)
3200 // Resend the original request again with only one e2 subscription (detail), this time with restsubsid
3201 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3202 assert.Equal(t, restSubId_resend, restSubId_resend2)
3204 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3205 assert.Equal(t, e2SubsId, e2SubsId1)
3207 mainCtrl.WaitOngoingRequestMapEmpty()
3209 // Delete both e2 subscriptions
3210 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3211 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3212 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3214 waitSubsCleanup(t, e2SubsId, 10)
3215 mainCtrl.VerifyCounterValues(t)
3216 mainCtrl.VerifyAllClean(t)
3219 //-----------------------------------------------------------------------------
3221 // +-------+ +---------+ +---------+ +---------+
3222 // | xapp | | submgr | | e2term | | rtmgr |
3223 // +-------+ +---------+ +---------+ +---------+
3225 // | RESTSubReq | | |
3226 // |---------------->| | |
3227 // | RESTSubResp | | |
3228 // |<----------------| | |
3229 // | | RouteCreate | |
3230 // | |--------------------------->|
3231 // | | RouteResponse| |
3232 // | |<---------------------------|
3234 // | |------------->| |
3236 // | |<-------------| |
3237 // | RESTNotif1 | | |
3238 // |<----------------| | |
3239 // | RESTSubReq | | |
3240 // | [with RestSUbsId + one additional e2 subDetail]
3241 // |---------------->| | |
3242 // | RESTNotif1 | | |
3243 // | [for initial e2 subDetail] | |
3244 // |<----------------| | |
3245 // | | RouteCreate | |
3246 // | |--------------------------->|
3247 // | | RouteResponse| |
3248 // | |<---------------------------|
3250 // | |------------->| |
3252 // | |<-------------| |
3253 // | RESTNotif1 | | |
3254 // |<----------------| | |
3255 // | RESTSubReq | | |
3256 // | [without RESTsubsId initial request] |
3257 // |---------------->| | |
3258 // | RESTNotif1 | | |
3259 // |<----------------| | |
3260 // | RESTSubDelReq | | |
3261 // |---------------->| | |
3262 // | RESTSubDelResp| | |
3263 // |<----------------| | |
3264 // | | SubDelReq | |
3265 // | |------------->| |
3266 // | | SubDelResp | |
3267 // | |<-------------| |
3268 // | | SubDelReq | |
3269 // | |------------->| |
3270 // | | SubDelResp | |
3271 // | |<-------------| |
3274 //-----------------------------------------------------------------------------
3276 func TestRESTSubReqRetransmissionV5(t *testing.T) {
3277 CaseBegin("TestRESTSubReqRetransmissionV5")
3279 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3280 Counter{cRestSubReqFromXapp, 3},
3281 Counter{cDuplicateE2SubReq, 2},
3282 Counter{cRestSubRespToXapp, 3},
3283 Counter{cSubReqToE2, 2},
3284 Counter{cSubRespFromE2, 2},
3285 Counter{cRestSubNotifToXapp, 4},
3286 Counter{cRestSubDelReqFromXapp, 1},
3287 Counter{cSubDelReqToE2, 2},
3288 Counter{cSubDelRespFromE2, 2},
3289 Counter{cRestSubDelRespToXapp, 1},
3292 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3294 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3296 mainCtrl.WaitOngoingRequestMapEmpty()
3298 // Send modified request, this time with e2 subscriptions.
3299 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3300 params2.SetSubscriptionID(&restSubId)
3302 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3303 xappConn1.ExpectAnyNotification(t)
3304 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3305 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3307 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3308 assert.Equal(t, e2SubsId, e2SubsId1)
3309 // The first E2 subscription returns immediately, manually decrement expected request count for the remaining request handling
3310 xappConn1.DecrementRequestCount()
3312 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3314 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3315 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3316 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3317 assert.NotEqual(t, e2SubsId2, 0)
3319 mainCtrl.WaitOngoingRequestMapEmpty()
3321 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3322 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3323 xappConn1.ExpectAnyNotification(t)
3324 // Resend the original request again with only one e2 subscription (detail), WITHOUT restsubsid
3325 // md5sum shall find the original request
3326 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3327 assert.Equal(t, restSubId_resend, restSubId_resend2)
3329 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3330 assert.Equal(t, e2SubsId, e2SubsId1)
3332 mainCtrl.WaitOngoingRequestMapEmpty()
3334 // Delete both e2 subscriptions
3335 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3336 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3337 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3339 waitSubsCleanup(t, e2SubsId, 10)
3340 mainCtrl.VerifyCounterValues(t)
3341 mainCtrl.VerifyAllClean(t)
3344 //-----------------------------------------------------------------------------
3346 // +-------+ +---------+ +---------+ +---------+
3347 // | xapp | | submgr | | e2term | | rtmgr |
3348 // +-------+ +---------+ +---------+ +---------+
3350 // | RESTSubReq | | |
3351 // |---------------->| | |
3352 // | RESTSubResp | | |
3353 // |<----------------| | |
3354 // | | RouteCreate | |
3355 // | |--------------------------->|
3356 // | | RouteResponse| |
3357 // | |<---------------------------|
3359 // | |------------->| |
3361 // | |<-------------| |
3362 // | RESTNotif1 | | |
3363 // |<----------------| | |
3364 // | RESTSubReq | | |
3365 // | [with RestSUbsId + one additional e2 subDetail]
3366 // |---------------->| | |
3367 // | RESTNotif1 | | |
3368 // | [for initial e2 subDetail] | |
3369 // |<----------------| | |
3370 // | | RouteCreate | |
3371 // | |--------------------------->|
3372 // | | RouteResponse| |
3373 // | |<---------------------------|
3375 // | |------------->| |
3377 // | |<-------------| |
3378 // | RESTNotif1 | | |
3379 // |<----------------| | |
3380 // | RESTSubDelReq | | |
3381 // |---------------->| | |
3382 // | RESTSubDelResp| | |
3383 // |<----------------| | |
3384 // | | SubDelReq | |
3385 // | |------------->| |
3386 // | | SubDelResp | |
3387 // | |<-------------| |
3388 // | | SubDelReq | |
3389 // | |------------->| |
3390 // | | SubDelResp | |
3391 // | |<-------------| |
3392 // | RESTSubReq | | |
3393 // | [with RESTsubsId initial request] |
3394 // |---------------->| | |
3395 // | RESTSubResp | | |
3396 // |<----------------| | |
3397 // | | RouteCreate | |
3398 // | |--------------------------->|
3399 // | | RouteResponse| |
3400 // | |<---------------------------|
3402 // | |------------->| |
3404 // | |<-------------| |
3405 // | RESTNotif1 | | |
3406 // |<----------------| | |
3409 //-----------------------------------------------------------------------------
3410 func TestRESTSubReqRetransmissionV6(t *testing.T) {
3411 CaseBegin("TestRESTSubReqRetransmissionV6")
3413 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3414 Counter{cRestSubReqFromXapp, 3},
3415 Counter{cDuplicateE2SubReq, 1},
3416 Counter{cRestSubRespToXapp, 3},
3417 Counter{cSubReqToE2, 3},
3418 Counter{cSubRespFromE2, 3},
3419 Counter{cRestSubNotifToXapp, 4},
3420 Counter{cRestSubDelReqFromXapp, 2},
3421 Counter{cSubDelReqToE2, 3},
3422 Counter{cSubDelRespFromE2, 3},
3423 Counter{cRestSubDelRespToXapp, 2},
3426 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3428 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3430 mainCtrl.WaitOngoingRequestMapEmpty()
3432 // Send modified requst, this time with e2 subscriptions.
3433 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3434 params2.SetSubscriptionID(&restSubId)
3436 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3437 xappConn1.ExpectAnyNotification(t)
3438 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3439 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3441 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3442 assert.Equal(t, e2SubsId, e2SubsId1)
3444 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3446 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3447 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3448 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3449 assert.NotEqual(t, e2SubsId2, 0)
3451 mainCtrl.WaitOngoingRequestMapEmpty()
3453 // Delete both e2 subscriptions
3454 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3455 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3456 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3458 waitSubsCleanup(t, e2SubsId, 10)
3460 // Resend the original request, we shall find it's previous md5sum/restsubs
3461 // but the restsubscription has been already removed. This shall trigger a
3463 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
3465 mainCtrl.WaitOngoingRequestMapEmpty()
3467 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3469 waitSubsCleanup(t, e2SubsId, 10)
3470 mainCtrl.VerifyCounterValues(t)
3471 mainCtrl.VerifyAllClean(t)
3474 func TestRESTSubDelReqRetransmission(t *testing.T) {
3475 CaseBegin("TestRESTSubDelReqRetransmission")
3477 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3478 Counter{cRestSubReqFromXapp, 1},
3479 Counter{cRestSubRespToXapp, 1},
3480 Counter{cSubReqToE2, 1},
3481 Counter{cSubRespFromE2, 1},
3482 Counter{cRestSubNotifToXapp, 1},
3483 Counter{cRestSubDelReqFromXapp, 2},
3484 Counter{cSubDelReqToE2, 1},
3485 Counter{cSubDelRespFromE2, 1},
3486 Counter{cRestSubDelRespToXapp, 2},
3489 var params *teststube2ap.RESTSubsReqParams = nil
3492 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3494 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3497 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3498 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3500 seqBef := mainCtrl.get_msgcounter(t)
3501 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3502 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
3504 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3506 waitSubsCleanup(t, e2SubsId, 10)
3507 mainCtrl.VerifyCounterValues(t)
3508 mainCtrl.VerifyAllClean(t)
3511 //-----------------------------------------------------------------------------
3512 // TestRESTSubReqDelReq
3515 // +-------+ +---------+ +---------+
3516 // | xapp | | submgr | | e2term |
3517 // +-------+ +---------+ +---------+
3520 // |---------------->| |
3522 // | RESTSubResp | |
3523 // |<----------------| |
3525 // | |------------->|
3526 // | RESTSubDelReq | |
3527 // |---------------->| |
3528 // | RESTSubDelResp | |
3530 // |<----------------| |
3532 // | |<-------------|
3534 // |<----------------| |
3536 // | [SUBS DELETE] |
3539 //-----------------------------------------------------------------------------
3540 func TestRESTSubReqDelReq(t *testing.T) {
3541 CaseBegin("TestRESTSubReqDelReq")
3543 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3544 Counter{cRestSubReqFromXapp, 1},
3545 Counter{cRestSubRespToXapp, 1},
3546 Counter{cSubReqToE2, 1},
3547 Counter{cSubRespFromE2, 1},
3548 Counter{cRestSubNotifToXapp, 1},
3549 Counter{cRestSubDelReqFromXapp, 2},
3550 Counter{cRestSubDelFailToXapp, 1},
3551 Counter{cSubDelReqToE2, 1},
3552 Counter{cSubDelRespFromE2, 1},
3553 Counter{cRestSubDelRespToXapp, 1},
3556 const subReqCount int = 1
3559 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3560 restSubId := xappConn1.SendRESTSubsReq(t, params)
3562 // Del. This will fail as processing of the subscription
3563 // is still ongoing in submgr. Deletion is not allowed before
3564 // subscription creation has been completed.
3565 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3566 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3567 xappConn1.ExpectRESTNotification(t, restSubId)
3568 e2termConn1.SendSubsResp(t, crereq, cremsg)
3569 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3572 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3574 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3575 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3577 // Wait that subs is cleaned
3578 waitSubsCleanup(t, e2SubsId, 10)
3579 mainCtrl.VerifyCounterValues(t)
3580 mainCtrl.VerifyAllClean(t)
3583 func TestRESTSubDelReqCollision(t *testing.T) {
3584 CaseBegin("TestRESTSubDelReqCollision - not relevant for REST API")
3587 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
3588 CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel")
3590 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3591 Counter{cRestSubReqFromXapp, 2},
3592 Counter{cRestSubRespToXapp, 2},
3593 Counter{cSubReqToE2, 2},
3594 Counter{cSubRespFromE2, 2},
3595 Counter{cRestSubNotifToXapp, 2},
3596 Counter{cRestSubDelReqFromXapp, 2},
3597 Counter{cSubDelReqToE2, 2},
3598 Counter{cSubDelRespFromE2, 2},
3599 Counter{cRestSubDelRespToXapp, 2},
3603 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3604 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3605 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3608 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3609 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3610 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3612 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3613 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3615 //XappConn1 receives both of the responses
3616 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3619 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3621 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3623 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3624 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3625 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3626 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3629 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3631 deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
3633 //Wait that subs is cleaned
3634 mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
3635 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
3637 mainCtrl.VerifyCounterValues(t)
3638 mainCtrl.VerifyAllClean(t)
3641 func TestRESTSameSubsDiffRan(t *testing.T) {
3642 CaseBegin("TestRESTSameSubsDiffRan")
3644 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3645 Counter{cRestSubReqFromXapp, 2},
3646 Counter{cRestSubRespToXapp, 2},
3647 Counter{cSubReqToE2, 2},
3648 Counter{cSubRespFromE2, 2},
3649 Counter{cRestSubNotifToXapp, 2},
3650 Counter{cRestSubDelReqFromXapp, 2},
3651 Counter{cSubDelReqToE2, 2},
3652 Counter{cSubDelRespFromE2, 2},
3653 Counter{cRestSubDelRespToXapp, 2},
3656 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3657 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3658 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3660 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3661 params.SetMeid("RAN_NAME_2")
3662 restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
3663 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3666 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3668 deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
3670 //Wait that subs is cleaned
3671 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3672 waitSubsCleanup(t, e2SubsId2, 10)
3674 mainCtrl.VerifyCounterValues(t)
3675 mainCtrl.VerifyAllClean(t)
3678 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
3679 CaseBegin("TestRESTSubReqRetryInSubmgr start")
3681 // Init counter check
3682 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3683 Counter{cRestSubReqFromXapp, 1},
3684 Counter{cRestSubRespToXapp, 1},
3685 Counter{cSubReqToE2, 1},
3686 Counter{cSubReqTimerExpiry, 1},
3687 Counter{cSubReReqToE2, 1},
3688 Counter{cSubRespFromE2, 1},
3689 Counter{cRestSubNotifToXapp, 1},
3690 Counter{cRestSubDelReqFromXapp, 1},
3691 Counter{cSubDelReqToE2, 1},
3692 Counter{cSubDelRespFromE2, 1},
3693 Counter{cRestSubDelRespToXapp, 1},
3696 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3697 restSubId := xappConn1.SendRESTSubsReq(t, params)
3699 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3701 // Catch the first message and ignore it
3702 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3703 xapp.Logger.Debug("Ignore REST subscriber request for subscriber : %v", restSubId)
3705 // The second request is being handled normally
3706 crereq, cremsg = e2termConn1.RecvSubsReq(t)
3707 xappConn1.ExpectRESTNotification(t, restSubId)
3708 e2termConn1.SendSubsResp(t, crereq, cremsg)
3709 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3711 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3713 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3715 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
3716 //Wait that subs is cleaned
3717 waitSubsCleanup(t, e2SubsId, 10)
3719 mainCtrl.VerifyCounterValues(t)
3720 mainCtrl.VerifyAllClean(t)
3723 //-----------------------------------------------------------------------------
3724 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3727 // +-------+ +---------+ +---------+
3728 // | xapp | | submgr | | e2term |
3729 // +-------+ +---------+ +---------+
3732 // |---------------->| |
3734 // | RESTSubResp | |
3735 // |<----------------| |
3737 // | |------------->|
3741 // | |------------->|
3744 // | |------------->|
3748 // | |------------->|
3752 // | |<-------------|
3755 // |<----------------| |
3757 // | [SUBS DELETE] |
3760 //-----------------------------------------------------------------------------
3762 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
3763 CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
3765 // Init counter check
3766 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3767 Counter{cRestSubReqFromXapp, 1},
3768 Counter{cRestSubRespToXapp, 1},
3769 Counter{cSubReqToE2, 1},
3770 Counter{cSubReReqToE2, 1},
3771 Counter{cSubReqTimerExpiry, 2},
3772 Counter{cRestSubFailNotifToXapp, 1},
3773 Counter{cSubDelReqToE2, 1},
3774 Counter{cSubDelRespFromE2, 1},
3775 Counter{cRestSubDelReqFromXapp, 1},
3776 Counter{cRestSubDelRespToXapp, 1},
3779 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3780 restSubId := xappConn1.SendRESTSubsReq(t, params)
3781 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3783 e2termConn1.RecvSubsReq(t)
3784 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3786 e2termConn1.RecvSubsReq(t)
3787 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3789 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3790 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3791 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3792 xappConn1.WaitRESTNotification(t, restSubId)
3794 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3796 // Wait that subs is cleaned
3797 waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
3798 mainCtrl.VerifyCounterValues(t)
3799 mainCtrl.VerifyAllClean(t)
3802 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
3803 CaseBegin("TestREST2eTermNotRespondingToSubReq start")
3805 // Init counter check
3806 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3807 Counter{cRestSubReqFromXapp, 1},
3808 Counter{cRestSubRespToXapp, 1},
3809 Counter{cSubReqToE2, 1},
3810 Counter{cSubReReqToE2, 1},
3811 Counter{cSubReqTimerExpiry, 2},
3812 Counter{cSubDelReReqToE2, 1},
3813 Counter{cRestSubFailNotifToXapp, 1},
3814 Counter{cSubDelReqToE2, 1},
3815 Counter{cSubDelReqTimerExpiry, 2},
3816 Counter{cRestSubDelReqFromXapp, 1},
3817 Counter{cRestSubDelRespToXapp, 1},
3820 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3821 restSubId := xappConn1.SendRESTSubsReq(t, params)
3822 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3824 e2termConn1.RecvSubsReq(t)
3825 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3827 e2termConn1.RecvSubsReq(t)
3828 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3830 e2termConn1.RecvSubsDelReq(t)
3831 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3833 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3834 e2termConn1.RecvSubsDelReq(t)
3835 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3837 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3839 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3841 waitSubsCleanup(t, e2SubsId, 10)
3842 mainCtrl.VerifyCounterValues(t)
3843 mainCtrl.VerifyAllClean(t)
3846 //-----------------------------------------------------------------------------
3847 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3850 // +-------+ +---------+ +---------+
3851 // | xapp | | submgr | | e2term |
3852 // +-------+ +---------+ +---------+
3855 // |---------------->| |
3857 // | RESTSubResp | |
3858 // |<----------------| |
3860 // | |------------->|
3864 // | |------------->|
3867 // | |------------->|
3871 // | |------------->|
3875 // | |<-------------|
3878 // |<----------------| |
3880 // | [SUBS DELETE] |
3883 //-----------------------------------------------------------------------------
3884 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
3885 CaseBegin("TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr start")
3887 // Init counter check
3888 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3889 Counter{cRestSubReqFromXapp, 1},
3890 Counter{cRestSubRespToXapp, 1},
3891 Counter{cSubReqToE2, 1},
3892 Counter{cSubReReqToE2, 1},
3893 Counter{cSubReqTimerExpiry, 2},
3894 Counter{cRestSubFailNotifToXapp, 1},
3895 Counter{cSubDelReqToE2, 1},
3896 Counter{cSubDelReReqToE2, 1},
3897 Counter{cSubDelReqTimerExpiry, 2},
3898 Counter{cRestSubDelReqFromXapp, 1},
3899 Counter{cRestSubDelRespToXapp, 1},
3902 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3903 restSubId := xappConn1.SendRESTSubsReq(t, params)
3904 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3906 e2termConn1.RecvSubsReq(t)
3907 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3909 e2termConn1.RecvSubsReq(t)
3910 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3912 e2termConn1.RecvSubsDelReq(t)
3913 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3915 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3916 e2termConn1.RecvSubsDelReq(t)
3917 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3919 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3921 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3923 waitSubsCleanup(t, e2SubsId, 10)
3924 mainCtrl.VerifyCounterValues(t)
3925 mainCtrl.VerifyAllClean(t)
3928 //-----------------------------------------------------------------------------
3929 // TestRESTSubReqSubFailRespInSubmgr
3932 // +-------+ +---------+ +---------+
3933 // | xapp | | submgr | | e2term |
3934 // +-------+ +---------+ +---------+
3937 // |---------------->| |
3939 // | RESTSubResp | |
3940 // |<----------------| |
3942 // | |------------->|
3945 // | |<-------------|
3949 // |<----------------| |
3951 // | [SUBS DELETE] |
3954 //-----------------------------------------------------------------------------
3955 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
3956 CaseBegin("TestRESTSubReqSubFailRespInSubmgr")
3958 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3959 Counter{cRestSubReqFromXapp, 1},
3960 Counter{cRestSubRespToXapp, 1},
3961 Counter{cSubReqToE2, 1},
3962 Counter{cSubFailFromE2, 1},
3963 Counter{cRestSubFailNotifToXapp, 1},
3964 Counter{cRestSubDelReqFromXapp, 1},
3965 Counter{cRestSubDelRespToXapp, 1},
3968 const subReqCount int = 1
3969 const e2Timeout int64 = 2
3970 const e2RetryCount int64 = 1
3971 const routingNeeded bool = true
3973 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3974 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
3975 restSubId := xappConn1.SendRESTSubsReq(t, params)
3977 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3978 fparams1 := &teststube2ap.E2StubSubsFailParams{}
3979 fparams1.Set(crereq1)
3980 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3981 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3983 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3984 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
3986 // REST subscription sill there to be deleted
3987 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3989 // Wait that subs is cleaned
3990 waitSubsCleanup(t, e2SubsId, 10)
3992 mainCtrl.VerifyCounterValues(t)
3993 mainCtrl.VerifyAllClean(t)
3996 //-----------------------------------------------------------------------------
3997 // TestRESTSubDelReqRetryInSubmgr
4000 // +-------+ +---------+ +---------+
4001 // | xapp | | submgr | | e2term |
4002 // +-------+ +---------+ +---------+
4004 // | [SUBS CREATE] |
4007 // | RESTSubDelReq | |
4008 // |---------------->| |
4010 // | RESTSubDelResp | |
4011 // |<----------------| |
4013 // | |------------->|
4016 // | |------------->|
4019 // | |<-------------|
4022 //-----------------------------------------------------------------------------
4023 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
4024 CaseBegin("TestRESTSubDelReqRetryInSubmgr")
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, 1},
4033 Counter{cSubDelReqToE2, 1},
4034 Counter{cSubDelReqTimerExpiry, 1},
4035 Counter{cSubDelReReqToE2, 1},
4036 Counter{cSubDelRespFromE2, 1},
4037 Counter{cRestSubDelRespToXapp, 1},
4040 var params *teststube2ap.RESTSubsReqParams = nil
4041 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4044 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4046 // E2t: Receive 1st SubsDelReq
4047 e2termConn1.RecvSubsDelReq(t)
4049 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4050 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4051 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4053 //Wait that subs is cleaned
4054 waitSubsCleanup(t, e2SubsId, 10)
4056 mainCtrl.VerifyCounterValues(t)
4057 mainCtrl.VerifyAllClean(t)
4060 //-----------------------------------------------------------------------------
4061 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
4064 // +-------+ +---------+ +---------+
4065 // | xapp | | submgr | | e2term |
4066 // +-------+ +---------+ +---------+
4068 // | [SUBS CREATE] |
4071 // | RESTSubDelReq | |
4072 // |---------------->| |
4074 // | RESTSubDelResp | |
4075 // |<----------------| |
4077 // | |------------->|
4080 // | |------------->|
4084 //-----------------------------------------------------------------------------
4085 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
4086 CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr")
4088 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4089 Counter{cRestSubReqFromXapp, 1},
4090 Counter{cRestSubRespToXapp, 1},
4091 Counter{cSubReqToE2, 1},
4092 Counter{cSubRespFromE2, 1},
4093 Counter{cRestSubNotifToXapp, 1},
4094 Counter{cRestSubDelReqFromXapp, 1},
4095 Counter{cSubDelReqToE2, 1},
4096 Counter{cSubDelReqTimerExpiry, 1},
4097 Counter{cSubDelReReqToE2, 1},
4098 Counter{cSubDelRespFromE2, 1},
4099 Counter{cRestSubDelRespToXapp, 1},
4103 var params *teststube2ap.RESTSubsReqParams = nil
4104 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4107 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4109 // E2t: Receive 1st SubsDelReq
4110 e2termConn1.RecvSubsDelReq(t)
4112 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4113 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4114 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4116 //Wait that subs is cleaned
4117 waitSubsCleanup(t, e2SubsId, 10)
4119 mainCtrl.VerifyCounterValues(t)
4120 mainCtrl.VerifyAllClean(t)
4123 //-----------------------------------------------------------------------------
4124 // TestRESTSubDelReqSubDelFailRespInSubmgr
4127 // +-------+ +---------+ +---------+
4128 // | xapp | | submgr | | e2term |
4129 // +-------+ +---------+ +---------+
4131 // | [SUBS CREATE] |
4134 // | RESTSubDelReq | |
4135 // |---------------->| |
4137 // | RESTSubDelResp | |
4138 // |<----------------| |
4140 // | |------------->|
4143 // | |<-------------|
4146 //-----------------------------------------------------------------------------
4147 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
4148 CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr")
4150 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4151 Counter{cRestSubReqFromXapp, 1},
4152 Counter{cRestSubRespToXapp, 1},
4153 Counter{cSubReqToE2, 1},
4154 Counter{cSubRespFromE2, 1},
4155 Counter{cRestSubNotifToXapp, 1},
4156 Counter{cRestSubDelReqFromXapp, 1},
4157 Counter{cSubDelReqToE2, 1},
4158 Counter{cSubDelFailFromE2, 1},
4159 Counter{cRestSubDelRespToXapp, 1},
4163 var params *teststube2ap.RESTSubsReqParams = nil
4164 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4167 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4169 // E2t: Send receive SubsDelReq and send SubsDelFail
4170 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4171 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
4173 //Wait that subs is cleaned
4174 waitSubsCleanup(t, e2SubsId, 10)
4176 mainCtrl.VerifyCounterValues(t)
4177 mainCtrl.VerifyAllClean(t)
4180 //-----------------------------------------------------------------------------
4181 // TestRESTSubReqAndSubDelOkSameAction
4184 // +-------+ +-------+ +---------+ +---------+
4185 // | xapp2 | | xapp1 | | submgr | | e2term |
4186 // +-------+ +-------+ +---------+ +---------+
4188 // | | RESTSubReq1 | |
4189 // | |---------------->| |
4191 // | | RESTSubResp1 | |
4192 // | |<----------------| |
4195 // | | |------------->|
4197 // | | |<-------------|
4198 // | | RESTNotif1 | |
4199 // | |<----------------| |
4201 // | RESTSubReq2 | |
4202 // |------------------------------>| |
4204 // | RESTSubResp2 | |
4205 // |<------------------------------| |
4207 // | | RESTNotif2 | |
4208 // |<------------------------------| |
4210 // | | RESTSubDelReq1 | |
4211 // | |---------------->| |
4213 // | | RESTSubDelResp1 | |
4214 // | |<----------------| |
4216 // | RESTSubDelReq2 | |
4217 // |------------------------------>| |
4219 // | RESTSubDelResp2 | |
4220 // |<------------------------------| |
4222 // | | | SubDelReq2 |
4223 // | | |------------->|
4225 // | | | SubDelResp2 |
4226 // | | |<-------------|
4229 //-----------------------------------------------------------------------------
4230 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
4231 CaseBegin("TestRESTSubReqAndSubDelOkSameAction")
4233 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4234 Counter{cRestSubReqFromXapp, 2},
4235 Counter{cRestSubRespToXapp, 2},
4236 Counter{cSubReqToE2, 1},
4237 Counter{cSubRespFromE2, 1},
4238 Counter{cRestSubNotifToXapp, 2},
4239 Counter{cMergedSubscriptions, 1},
4240 Counter{cUnmergedSubscriptions, 1},
4241 Counter{cRestSubDelReqFromXapp, 2},
4242 Counter{cSubDelReqToE2, 1},
4243 Counter{cSubDelRespFromE2, 1},
4244 Counter{cRestSubDelRespToXapp, 2},
4248 var params *teststube2ap.RESTSubsReqParams = nil
4251 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4252 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4255 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4256 params.SetMeid("RAN_NAME_1")
4258 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4259 xappConn2.ExpectAnyNotification(t)
4260 waiter := rtmgrHttp.AllocNextSleep(10, true)
4261 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4262 waiter.WaitResult(t)
4263 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
4264 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
4265 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
4267 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
4270 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4273 deleteXapp2Subscription(t, &restSubId2)
4275 //Wait that subs is cleaned
4276 waitSubsCleanup(t, e2SubsId2, 10)
4277 mainCtrl.VerifyCounterValues(t)
4278 mainCtrl.VerifyAllClean(t)
4281 //-----------------------------------------------------------------------------
4282 // TestSubReqAndSubDelOkSameActionParallel
4285 // +-------+ +-------+ +---------+ +---------+
4286 // | xapp2 | | xapp1 | | submgr | | e2term |
4287 // +-------+ +-------+ +---------+ +---------+
4292 // | |------------->| |
4295 // | | |------------->|
4297 // |--------------------------->| |
4299 // | | |<-------------|
4301 // | |<-------------| |
4303 // | | |------------->|
4306 // | | |<-------------|
4308 // |<---------------------------| |
4310 // | | SubDelReq 1 | |
4311 // | |------------->| |
4313 // | | SubDelResp 1 | |
4314 // | |<-------------| |
4316 // | SubDelReq 2 | |
4317 // |--------------------------->| |
4319 // | | | SubDelReq 2 |
4320 // | | |------------->|
4322 // | | | SubDelReq 2 |
4323 // | | |------------->|
4325 // | SubDelResp 2 | |
4326 // |<---------------------------| |
4328 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
4329 CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel")
4331 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4332 Counter{cRestSubReqFromXapp, 2},
4333 Counter{cRestSubRespToXapp, 2},
4334 Counter{cSubReqToE2, 2},
4335 Counter{cSubRespFromE2, 2},
4336 Counter{cRestSubNotifToXapp, 2},
4337 Counter{cRestSubDelReqFromXapp, 2},
4338 Counter{cSubDelReqToE2, 2},
4339 Counter{cSubDelRespFromE2, 2},
4340 Counter{cRestSubDelRespToXapp, 2},
4343 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4344 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4345 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4347 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4348 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4350 xappConn1.ExpectRESTNotification(t, restSubId1)
4351 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4352 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4354 xappConn2.ExpectRESTNotification(t, restSubId2)
4355 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
4356 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
4357 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4360 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4361 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4362 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4363 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4366 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4367 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
4368 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
4370 waitSubsCleanup(t, e2SubsId2, 10)
4371 mainCtrl.VerifyCounterValues(t)
4372 mainCtrl.VerifyAllClean(t)
4375 //-----------------------------------------------------------------------------
4376 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
4379 // +-------+ +-------+ +---------+ +---------+
4380 // | xapp2 | | xapp1 | | submgr | | e2term |
4381 // +-------+ +-------+ +---------+ +---------+
4385 // | | RESTSubReq1 | |
4386 // | |---------------->| |
4388 // | | RESTSubResp1 | |
4389 // | |<----------------| |
4391 // | | |------------->|
4392 // | RESTSubReq2 | |
4393 // |------------------------------>| |
4395 // | RESTSubResp2 | |
4396 // |<------------------------------| |
4398 // | | |------------->|
4401 // | | | SubDelReq |
4402 // | | |------------->|
4404 // | | | SubDelResp |
4405 // | | |<-------------|
4406 // | | RESTNotif1 | |
4407 // | | unsuccess | |
4408 // | |<----------------| |
4410 // | | unsuccess | |
4411 // |<------------------------------| |
4413 // | | RESTSubDelReq1 | |
4414 // | |---------------->| |
4416 // | | RESTSubDelResp1 | |
4417 // | |<----------------| |
4419 // | RESTSubDelReq2 | |
4420 // |------------------------------>| |
4422 // | RESTSubDelResp2 | |
4423 // |<------------------------------| |
4425 //-----------------------------------------------------------------------------
4426 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
4427 CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
4429 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4430 Counter{cRestSubReqFromXapp, 2},
4431 Counter{cMergedSubscriptions, 1},
4432 Counter{cRestSubRespToXapp, 2},
4433 Counter{cSubReqToE2, 1},
4434 Counter{cSubReqTimerExpiry, 2},
4435 Counter{cSubReReqToE2, 1},
4436 Counter{cRestSubFailNotifToXapp, 2},
4437 Counter{cUnmergedSubscriptions, 1},
4438 Counter{cRestSubDelReqFromXapp, 2},
4439 Counter{cSubDelReqToE2, 1},
4440 Counter{cSubDelRespFromE2, 1},
4441 Counter{cRestSubDelRespToXapp, 2},
4443 const subReqCount int = 1
4446 params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4447 restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
4448 crereq1, _ := e2termConn1.RecvSubsReq(t)
4451 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4452 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4453 params2.SetMeid("RAN_NAME_1")
4454 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4455 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4457 //Req1 (retransmitted)
4458 e2termConn1.RecvSubsReq(t)
4460 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4462 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4463 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4465 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4466 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4467 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4468 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4471 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4474 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4476 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
4478 //Wait that subs is cleaned
4479 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4480 mainCtrl.VerifyCounterValues(t)
4481 mainCtrl.VerifyAllClean(t)
4484 //-----------------------------------------------------------------------------
4485 // TestRESTSubReqAndSubDelNokSameActionParallel
4488 // +-------+ +-------+ +---------+ +---------+
4489 // | xapp2 | | xapp1 | | submgr | | e2term |
4490 // +-------+ +-------+ +---------+ +---------+
4494 // | | RESTSubReq1 | |
4495 // | |---------------->| |
4497 // | | RESTSubResp1 | |
4498 // | |<----------------| |
4500 // | | |------------->|
4501 // | RESTSubReq2 | |
4502 // |------------------------------>| |
4504 // | RESTSubDelResp2 | |
4505 // |<------------------------------| |
4507 // | | |<-------------|
4509 // | | RESTNotif1 | |
4510 // | | unsuccess | |
4511 // | |<----------------| |
4513 // | | unsuccess | |
4514 // |<------------------------------| |
4516 // | | RESTSubDelReq1 | | There is no need for xApp to send delete for failed subscriptions but some xApp might do so.
4517 // | |---------------->| |
4519 // | | RESTSubDelResp1 | |
4520 // | |<----------------| |
4522 // | RESTSubDelReq2 | |
4523 // |------------------------------>| |
4525 // | RESTSubDelResp2 | |
4526 // |<------------------------------| |
4528 //-----------------------------------------------------------------------------
4529 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
4530 CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
4532 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4533 Counter{cRestSubReqFromXapp, 2},
4534 Counter{cMergedSubscriptions, 1},
4535 Counter{cRestSubRespToXapp, 2},
4536 Counter{cSubReqToE2, 1},
4537 Counter{cSubFailFromE2, 1},
4538 Counter{cRestSubFailNotifToXapp, 2},
4539 Counter{cUnmergedSubscriptions, 1},
4540 Counter{cRestSubDelReqFromXapp, 2},
4541 Counter{cRestSubDelRespToXapp, 2},
4544 const subReqCount int = 1
4547 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4548 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4549 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4552 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4553 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4554 params2.SetMeid("RAN_NAME_1")
4555 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4556 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4558 // E2t: send SubsFail (first)
4559 fparams1 := &teststube2ap.E2StubSubsFailParams{}
4560 fparams1.Set(crereq1)
4561 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
4563 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4564 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4565 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4566 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4567 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4570 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4573 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4575 //Wait that subs is cleaned
4576 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4577 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
4578 mainCtrl.VerifyCounterValues(t)
4579 mainCtrl.VerifyAllClean(t)
4582 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
4583 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4585 // Init counter check
4586 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4587 Counter{cRestSubReqFromXapp, 1},
4588 Counter{cRestSubRespToXapp, 1},
4589 Counter{cSubReqToE2, 1},
4590 Counter{cSubRespFromE2, 1},
4591 Counter{cRestSubNotifToXapp, 1},
4592 Counter{cRestSubDelReqFromXapp, 1},
4593 Counter{cSubDelReqToE2, 1},
4594 Counter{cSubDelRespFromE2, 1},
4595 Counter{cRestSubDelRespToXapp, 1},
4598 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4599 restSubId := xappConn1.SendRESTSubsReq(t, params)
4600 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
4602 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4603 xappConn1.ExpectRESTNotification(t, restSubId)
4604 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4605 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4606 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
4608 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4609 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4610 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4612 // Wait that subs is cleaned
4613 waitSubsCleanup(t, e2SubsId, 10)
4614 mainCtrl.VerifyCounterValues(t)
4615 mainCtrl.VerifyAllClean(t)
4618 //-----------------------------------------------------------------------------
4619 // TestRESTSubReqPolicyChangeAndSubDelOk
4622 // +-------+ +---------+ +---------+
4623 // | xapp | | submgr | | e2term |
4624 // +-------+ +---------+ +---------+
4627 // |---------------->| |
4629 // | RESTSubResp | |
4630 // |<----------------| |
4632 // | |------------->|
4635 // | |<-------------|
4638 // |<----------------| |
4641 // |---------------->| |
4643 // | RESTSubResp | |
4644 // |<----------------| |
4646 // | |------------->|
4649 // | |<-------------|
4652 // |<----------------| |
4654 // | RESTSubDelReq | |
4655 // |---------------->| |
4658 // | |------------->|
4661 // | |<-------------|
4663 // | RESTSubDelResp | |
4664 // |<----------------| |
4666 //-----------------------------------------------------------------------------
4667 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
4668 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4670 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4671 Counter{cRestSubReqFromXapp, 2},
4672 Counter{cRestSubRespToXapp, 2},
4673 Counter{cSubReqToE2, 2},
4674 Counter{cSubRespFromE2, 2},
4675 Counter{cRestSubNotifToXapp, 2},
4676 Counter{cRestSubDelReqFromXapp, 1},
4677 Counter{cSubDelReqToE2, 1},
4678 Counter{cSubDelRespFromE2, 1},
4679 Counter{cRestSubDelRespToXapp, 1},
4682 const subReqCount int = 1
4683 const e2Timeout int64 = 1
4684 const e2RetryCount int64 = 0
4685 const routingNeeded bool = true
4688 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4689 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4690 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4693 // GetRESTSubsReqPolicyParams sets some counters on tc side.
4695 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4696 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4697 params.SetSubscriptionID(&restSubId)
4698 params.SetTimeToWait("w200ms")
4699 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
4702 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4704 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4705 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4707 // Wait that subs is cleaned
4708 waitSubsCleanup(t, e2SubsId, 10)
4709 mainCtrl.VerifyCounterValues(t)
4710 mainCtrl.VerifyAllClean(t)
4713 //-----------------------------------------------------------------------------
4714 // TestRESTSubReqPolicyChangeNOk
4717 // +-------+ +---------+ +---------+
4718 // | xapp | | submgr | | e2term |
4719 // +-------+ +---------+ +---------+
4722 // |---------------->| |
4724 // | RESTSubResp | |
4725 // |<----------------| |
4727 // | |------------->|
4730 // | |<-------------|
4733 // |<----------------| |
4736 // |---------------->| |
4738 // | RESTSubUpdateFail(400 Bad request)
4740 // | RESTSubDelReq | |
4741 // |---------------->| |
4744 // | |------------->|
4747 // | |<-------------|
4749 // | RESTSubDelResp | |
4750 // |<----------------| |
4752 //-----------------------------------------------------------------------------
4753 func TestRESTSubReqPolicyChangeNOk(t *testing.T) {
4754 CaseBegin("TestRESTSubReqPolicyChangeNOk")
4756 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4757 Counter{cRestSubReqFromXapp, 2},
4758 Counter{cRestSubRespToXapp, 1},
4759 Counter{cSubReqToE2, 1},
4760 Counter{cSubRespFromE2, 1},
4761 Counter{cRestSubNotifToXapp, 1},
4762 Counter{cRestSubFailToXapp, 1},
4763 Counter{cRestSubDelReqFromXapp, 1},
4764 Counter{cSubDelReqToE2, 1},
4765 Counter{cSubDelRespFromE2, 1},
4766 Counter{cRestSubDelRespToXapp, 1},
4770 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4771 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4774 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4776 restSubIdUpd := strings.ToUpper(restSubId) // This makes RESTSubReq to fail
4777 params.SetSubscriptionID(&restSubIdUpd)
4778 params.SetTimeToWait("w200ms")
4780 restSubId2 := xappConn1.SendRESTSubsReq(t, params)
4781 assert.Equal(t, restSubId2, "")
4784 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4786 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4787 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4789 // Wait that subs is cleaned
4790 waitSubsCleanup(t, e2SubsId, 10)
4791 mainCtrl.VerifyCounterValues(t)
4792 mainCtrl.VerifyAllClean(t)
4795 //-----------------------------------------------------------------------------
4796 // TestRESTSubReqAndSubDelOkTwoE2termParallel
4799 // +-------+ +---------+ +---------+ +---------+
4800 // | xapp | | submgr | | e2term1 | | e2term2 |
4801 // +-------+ +---------+ +---------+ +---------+
4805 // | RESTSubReq1 | | |
4806 // |---------------->| | |
4808 // | RESTSubResp1 | | |
4809 // |<----------------| | |
4811 // | |------------->| |
4813 // | RESTSubReq2 | | |
4814 // |---------------->| | |
4816 // | RESTSubResp2 | | |
4817 // |<----------------| | |
4819 // | |---------------------------->|
4822 // | |<-------------| |
4823 // | RESTNotif1 | | |
4824 // |<----------------| | |
4826 // | |<----------------------------|
4827 // | RESTNotif2 | | |
4828 // |<----------------| | |
4830 // | [SUBS 1 DELETE] | |
4832 // | [SUBS 2 DELETE] | |
4835 //-----------------------------------------------------------------------------
4836 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
4837 CaseBegin("TestRESTSubReqAndSubDelOkTwoE2termParallel")
4839 // Init counter check
4840 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4841 Counter{cRestSubReqFromXapp, 2},
4842 Counter{cRestSubRespToXapp, 2},
4843 Counter{cSubReqToE2, 2},
4844 Counter{cSubRespFromE2, 2},
4845 Counter{cRestSubNotifToXapp, 2},
4846 Counter{cRestSubDelReqFromXapp, 2},
4847 Counter{cSubDelReqToE2, 2},
4848 Counter{cSubDelRespFromE2, 2},
4849 Counter{cRestSubDelRespToXapp, 2},
4852 const subReqCount int = 1
4855 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4856 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4857 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4860 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4861 params.SetMeid("RAN_NAME_11")
4862 // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
4863 // would not work as notification would not be received
4864 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4865 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
4868 xappConn1.ExpectRESTNotification(t, restSubId1)
4869 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4870 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4871 xapp.Logger.Debug("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
4874 xappConn2.ExpectRESTNotification(t, restSubId2)
4875 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
4876 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4877 xapp.Logger.Debug("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
4880 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4881 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4882 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4884 // Wait that subs is cleaned
4885 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4888 xappConn1.SendRESTSubsDelReq(t, &restSubId2)
4889 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
4890 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
4892 // Wait that subs is cleaned
4893 waitSubsCleanup(t, e2SubsId2, 10)
4895 mainCtrl.VerifyCounterValues(t)
4896 mainCtrl.VerifyAllClean(t)
4899 //-----------------------------------------------------------------------------
4900 // TestRESTSubReqAsn1EncodeFail
4902 // In this case submgr send RICSubscriptionDeleteRequest after encode failure which should not happen!
4904 // +-------+ +---------+ +---------+
4905 // | xapp | | submgr | | e2term |
4906 // +-------+ +---------+ +---------+
4909 // |---------------->| |
4911 // | RESTSubResp | |
4912 // |<----------------| |
4913 // | RESTSubDelReq | |
4914 // |---------------->| |
4915 // | RESTSubDelResp | |
4917 // |<----------------| |
4920 //-----------------------------------------------------------------------------
4921 func TestRESTSubReqAsn1EncodeFail(t *testing.T) {
4922 CaseBegin("TestRESTSubReqAsn1EncodeFail")
4924 xapp.Logger.Debug("Xapp-frame, v0.8.1 sufficient REST API validation")
4928 //-----------------------------------------------------------------------------
4929 // TestRESTSubReqInsertAndSubDelOk
4932 // +-------+ +---------+ +---------+
4933 // | xapp | | submgr | | e2term |
4934 // +-------+ +---------+ +---------+
4937 // |---------------->| |
4939 // | RESTSubResp | |
4940 // |<----------------| |
4943 // | |------------->|
4946 // | |<-------------|
4948 // |<----------------| |
4951 // | RESTSubDelReq | |
4952 // |---------------->| |
4955 // | |------------->|
4958 // | |<-------------|
4960 // | RESTSubDelResp| |
4961 // |<----------------| |
4963 //-----------------------------------------------------------------------------
4964 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
4965 CaseBegin("TestRESTInsertSubReqAndSubDelOk")
4967 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4968 Counter{cRestSubReqFromXapp, 1},
4969 Counter{cRestSubRespToXapp, 1},
4970 Counter{cSubReqToE2, 1},
4971 Counter{cSubRespFromE2, 1},
4972 Counter{cRestSubNotifToXapp, 1},
4973 Counter{cRestSubDelReqFromXapp, 1},
4974 Counter{cSubDelReqToE2, 1},
4975 Counter{cSubDelRespFromE2, 1},
4976 Counter{cRestSubDelRespToXapp, 1},
4979 const subReqCount int = 1
4981 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4982 params.SetSubActionTypes("insert")
4985 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4988 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4990 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4991 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4993 // Wait that subs is cleaned
4994 waitSubsCleanup(t, e2SubsId, 10)
4995 mainCtrl.VerifyCounterValues(t)
4996 mainCtrl.VerifyAllClean(t)
4999 //-----------------------------------------------------------------------------
5000 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
5003 // +-------+ +---------+ +---------+
5004 // | xapp | | submgr | | e2term |
5005 // +-------+ +---------+ +---------+
5008 // |------------->| |
5010 // | RESTSubResp | |
5011 // |<-------------| |
5013 // | |------------->|
5018 // | Submgr restart |
5022 // | |------------->|
5025 // | |<-------------|
5029 // |<-------------| |
5031 // | RESTSubDelReq| |
5032 // |------------->| |
5034 // |RESTSubDelResp| |
5035 // |<-------------| |
5037 //-----------------------------------------------------------------------------
5038 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
5039 CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle")
5041 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5042 Counter{cRestSubReqFromXapp, 1},
5043 Counter{cRestSubRespToXapp, 1},
5044 Counter{cSubReqToE2, 1},
5045 Counter{cSubDelReqFromXapp, 1},
5046 Counter{cSubDelReqToE2, 1},
5047 Counter{cSubDelRespFromE2, 1},
5048 Counter{cRestSubDelReqFromXapp, 1},
5049 Counter{cRestSubDelRespToXapp, 1},
5052 const subReqCount int = 1
5054 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5057 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
5058 restSubId := xappConn1.SendRESTSubsReq(t, params)
5059 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5061 e2termConn1.RecvSubsReq(t)
5063 mainCtrl.SetResetTestFlag(t, false)
5065 mainCtrl.SimulateRestart(t)
5066 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5068 // Deleletion of uncompleted subscription
5069 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5070 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5073 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5075 xappConn1.TestMsgChanEmpty(t)
5076 e2termConn1.TestMsgChanEmpty(t)
5077 mainCtrl.wait_registry_empty(t, 10)
5079 mainCtrl.VerifyCounterValues(t)
5080 mainCtrl.VerifyAllClean(t)
5083 //-----------------------------------------------------------------------------
5084 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
5087 // +-------+ +---------+ +---------+
5088 // | xapp | | submgr | | e2term |
5089 // +-------+ +---------+ +---------+
5092 // |---------------->| |
5094 // | RESTSubResp | |
5095 // |<----------------| |
5097 // | |------------->|
5100 // | |<-------------|
5103 // |<----------------| |
5106 // | Submgr restart |
5108 // | RESTSubDelReq | |
5109 // |---------------->| |
5112 // | |------------->|
5115 // | |<-------------|
5117 // | RESTSubDelResp | |
5118 // |<----------------| |
5120 //-----------------------------------------------------------------------------
5122 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
5123 CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle")
5125 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5126 Counter{cRestSubReqFromXapp, 1},
5127 Counter{cRestSubRespToXapp, 1},
5128 Counter{cSubReqToE2, 1},
5129 Counter{cSubRespFromE2, 1},
5130 Counter{cRestSubNotifToXapp, 1},
5131 Counter{cRestSubDelReqFromXapp, 1},
5132 Counter{cSubDelReqToE2, 1},
5133 Counter{cSubDelRespFromE2, 1},
5134 Counter{cRestSubDelRespToXapp, 1},
5137 // Create subscription
5138 var params *teststube2ap.RESTSubsReqParams = nil
5139 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5140 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5142 // Check subscription
5143 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5145 mainCtrl.SimulateRestart(t)
5146 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5148 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5149 // That needs to be completed before successful subscription query is possible
5150 <-time.After(time.Second * 1)
5152 // Check subscription
5153 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5155 // Delete subscription
5156 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
5158 //Wait that subs is cleaned
5159 waitSubsCleanup(t, e2SubsId, 10)
5161 mainCtrl.VerifyCounterValues(t)
5162 mainCtrl.VerifyAllClean(t)
5165 //-----------------------------------------------------------------------------
5166 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
5169 // +-------+ +-------+ +---------+ +---------+
5170 // | xapp2 | | xapp1 | | submgr | | e2term |
5171 // +-------+ +-------+ +---------+ +---------+
5173 // | | RESTSubReq1 | |
5174 // | |---------------->| |
5176 // | | RESTSubResp1 | |
5177 // | |<----------------| |
5180 // | | |------------->|
5182 // | | |<-------------|
5183 // | | RESTNotif1 | |
5184 // | |<----------------| |
5186 // | RESTSubReq2 | |
5187 // |------------------------------>| |
5189 // | RESTSubResp2 | |
5190 // |<------------------------------| |
5192 // | | RESTNotif2 | |
5193 // |<------------------------------| |
5195 // | | Submgr restart |
5197 // | | RESTSubDelReq1 | |
5198 // | |---------------->| |
5200 // | | RESTSubDelResp1 | |
5201 // | |<----------------| |
5203 // | | Submgr restart |
5205 // | RESTSubDelReq2 | |
5206 // |------------------------------>| |
5208 // | RESTSubDelResp2 | |
5209 // |<------------------------------| |
5211 // | | | SubDelReq2 |
5212 // | | |------------->|
5214 // | | | SubDelResp2 |
5215 // | | |<-------------|
5218 //-----------------------------------------------------------------------------
5219 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
5220 CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
5222 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5223 Counter{cRestSubReqFromXapp, 2},
5224 Counter{cRestSubRespToXapp, 2},
5225 Counter{cSubReqToE2, 1},
5226 Counter{cSubRespFromE2, 1},
5227 Counter{cRestSubNotifToXapp, 2},
5228 Counter{cMergedSubscriptions, 1},
5229 Counter{cUnmergedSubscriptions, 1},
5230 Counter{cRestSubDelReqFromXapp, 2},
5231 Counter{cSubDelReqToE2, 1},
5232 Counter{cSubDelRespFromE2, 1},
5233 Counter{cRestSubDelRespToXapp, 2},
5236 // Create subscription 1
5237 var params *teststube2ap.RESTSubsReqParams = nil
5238 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5239 xapp.Logger.Debug("Send REST subscriber request for subscriber 1 : %v", restSubId1)
5241 // Create subscription 2 with same action
5242 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5243 params.SetMeid("RAN_NAME_1")
5244 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
5245 xappConn2.ExpectAnyNotification(t)
5246 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5247 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5248 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
5249 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
5251 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
5253 mainCtrl.SimulateRestart(t)
5254 xapp.Logger.Debug("mainCtrl.SimulateRestart done 1")
5256 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5257 // That needs to be completed before successful subscription delete is possible
5258 <-time.After(time.Second * 1)
5260 // Delete subscription 1, and wait until it has removed the first endpoint
5261 subepcnt := mainCtrl.get_subs_entrypoint_cnt(t, e2SubsId1)
5262 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5263 mainCtrl.wait_subs_entrypoint_cnt_change(t, e2SubsId1, subepcnt, 10)
5265 // Above wait does not work correctly anymore as this delay makes this test case work
5266 //<-time.After(time.Second * 1)
5268 mainCtrl.SimulateRestart(t)
5269 xapp.Logger.Debug("mainCtrl.SimulateRestart done 2")
5271 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5272 // That needs to be completed before successful subscription query is possible
5273 <-time.After(time.Second * 1)
5275 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
5277 // Delete subscription 2
5278 deleteXapp2Subscription(t, &restSubId2)
5280 //Wait that subs is cleaned
5281 waitSubsCleanup(t, e2SubsId2, 10)
5283 mainCtrl.VerifyCounterValues(t)
5284 mainCtrl.VerifyAllClean(t)
5287 //-----------------------------------------------------------------------------
5288 // TestRESTReportSubReqAndSubDelOk
5291 // +-------+ +---------+ +---------+
5292 // | xapp | | submgr | | e2term |
5293 // +-------+ +---------+ +---------+
5296 // |---------------->| |
5298 // | RESTSubResp | |
5299 // |<----------------| |
5302 // | |------------->|
5305 // | |<-------------|
5307 // |<----------------| |
5309 // | |------------->|
5312 // | |<-------------|
5314 // |<----------------| |
5318 // | RESTSubDelReq | |
5319 // |---------------->| |
5321 // | RESTSubDelResp| |
5322 // |<----------------| |
5324 // | |------------->|
5327 // | |<-------------|
5330 //-----------------------------------------------------------------------------
5332 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
5333 CaseBegin("TestRESTReportSubReqAndSubDelOk")
5334 const subReqCount int = 1
5336 RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
5339 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5340 xapp.Logger.Debug("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
5342 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5343 Counter{cRestSubReqFromXapp, 1},
5344 Counter{cRestSubRespToXapp, 1},
5345 Counter{cSubReqToE2, uint64(subReqCount)},
5346 Counter{cSubRespFromE2, uint64(subReqCount)},
5347 Counter{cRestSubNotifToXapp, 1},
5348 Counter{cRestSubDelReqFromXapp, 1},
5349 Counter{cRestSubDelRespToXapp, 1},
5350 Counter{cSubDelReqToE2, uint64(subReqCount)},
5351 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5355 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5356 restSubId := xappConn1.SendRESTSubsReq(t, params)
5358 var e2SubsId []uint32
5359 for i := 0; i < subReqCount; i++ {
5360 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5361 xappConn1.ExpectRESTNotification(t, restSubId)
5363 e2termConn1.SendSubsResp(t, crereq, cremsg)
5364 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5365 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5366 e2SubsId = append(e2SubsId, instanceId)
5367 resp, _ := xapp.Subscription.QuerySubscriptions()
5368 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
5369 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
5370 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
5375 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5377 for i := 0; i < subReqCount; i++ {
5378 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5379 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5382 // Wait that subs is cleaned
5383 for i := 0; i < subReqCount; i++ {
5384 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5387 xappConn1.TestMsgChanEmpty(t)
5388 e2termConn1.TestMsgChanEmpty(t)
5389 mainCtrl.wait_registry_empty(t, 10)
5390 mainCtrl.VerifyAllClean(t)
5391 mainCtrl.VerifyCounterValues(t)
5395 func TestRESTPolicySubReqAndSubDelOk(t *testing.T) { //Was in comments already. Next case is not run!
5396 CaseBegin("TestRESTPolicySubReqAndSubDelOk")
5400 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5404 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5407 func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5408 xapp.Logger.Debug("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
5410 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5411 Counter{cRestSubReqFromXapp, 1},
5412 Counter{cRestSubRespToXapp, 1},
5413 Counter{cSubReqToE2, uint64(subReqCount)},
5414 Counter{cSubRespFromE2, uint64(subReqCount)},
5415 Counter{cRestSubNotifToXapp, 1},
5416 Counter{cRestSubDelReqFromXapp, 1},
5417 Counter{cRestSubDelRespToXapp, 1},
5418 Counter{cSubDelReqToE2, uint64(subReqCount)},
5419 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5423 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5424 restSubId := xappConn1.SendRESTSubsReq(t, params)
5426 var e2SubsId []uint32
5427 for i := 0; i < subReqCount; i++ {
5428 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5429 xappConn1.ExpectRESTNotification(t, restSubId)
5430 e2termConn1.SendSubsResp(t, crereq, cremsg)
5431 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5432 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5433 e2SubsId = append(e2SubsId, instanceId)
5437 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5439 for i := 0; i < subReqCount; i++ {
5440 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5441 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5444 // Wait that subs is cleaned
5445 for i := 0; i < subReqCount; i++ {
5446 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5448 xappConn1.TestMsgChanEmpty(t)
5449 e2termConn1.TestMsgChanEmpty(t)
5450 mainCtrl.wait_registry_empty(t, 10)
5451 mainCtrl.VerifyAllClean(t)
5452 mainCtrl.VerifyCounterValues(t)
5455 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
5457 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5458 Counter{cRestSubReqFromXapp, 1},
5459 Counter{cRestSubRespToXapp, 1},
5460 Counter{cSubReqToE2, 2},
5461 Counter{cSubRespFromE2, 2},
5462 Counter{cRestSubNotifToXapp, 2},
5463 Counter{cRestSubDelReqFromXapp, 1},
5464 Counter{cSubDelReqToE2, 2},
5465 Counter{cSubDelRespFromE2, 2},
5466 Counter{cRestSubDelRespToXapp, 1},
5469 const subReqCount int = 2
5472 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5473 restSubId := xappConn1.SendRESTSubsReq(t, params)
5474 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5476 assert.Equal(t, len(e2SubsIds), 2)
5479 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5480 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5482 xappConn1.TestMsgChanEmpty(t)
5483 e2termConn1.TestMsgChanEmpty(t)
5484 mainCtrl.wait_registry_empty(t, 10)
5486 mainCtrl.VerifyCounterValues(t)
5487 mainCtrl.VerifyAllClean(t)
5489 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
5491 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5492 Counter{cRestSubReqFromXapp, 1},
5493 Counter{cRestSubRespToXapp, 1},
5494 Counter{cSubReqToE2, 19},
5495 Counter{cSubRespFromE2, 19},
5496 Counter{cRestSubNotifToXapp, 19},
5497 Counter{cRestSubDelReqFromXapp, 1},
5498 Counter{cSubDelReqToE2, 19},
5499 Counter{cSubDelRespFromE2, 19},
5500 Counter{cRestSubDelRespToXapp, 1},
5503 const subReqCount int = 19
5505 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5506 restSubId := xappConn1.SendRESTSubsReq(t, params)
5507 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5509 assert.Equal(t, len(e2SubsIds), 19)
5511 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5512 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5514 xappConn1.TestMsgChanEmpty(t)
5515 e2termConn1.TestMsgChanEmpty(t)
5516 mainCtrl.wait_registry_empty(t, 10)
5518 mainCtrl.VerifyCounterValues(t)
5519 mainCtrl.VerifyAllClean(t)
5522 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
5526 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5527 Counter{cRestSubReqFromXapp, 1},
5528 Counter{cRestSubRespToXapp, 1},
5529 Counter{cSubReqToE2, uint64(subReqCount)},
5530 Counter{cSubRespFromE2, uint64(subReqCount)},
5531 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5532 Counter{cRestSubDelReqFromXapp, 1},
5533 Counter{cSubDelReqToE2, uint64(subReqCount)},
5534 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5535 Counter{cRestSubDelRespToXapp, 1},
5539 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5540 restSubId := xappConn1.SendRESTSubsReq(t, params)
5541 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5543 assert.Equal(t, len(e2SubsIds), subReqCount)
5546 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5547 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5549 xappConn1.TestMsgChanEmpty(t)
5550 e2termConn1.TestMsgChanEmpty(t)
5551 mainCtrl.wait_registry_empty(t, 10)
5553 mainCtrl.VerifyCounterValues(t)
5554 mainCtrl.VerifyAllClean(t)
5557 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
5561 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5562 Counter{cRestSubReqFromXapp, 1},
5563 Counter{cRestSubRespToXapp, 1},
5564 Counter{cSubReqToE2, uint64(subReqCount)},
5565 Counter{cSubRespFromE2, uint64(subReqCount)},
5566 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5567 Counter{cRestSubDelReqFromXapp, 1},
5568 Counter{cSubDelReqToE2, uint64(subReqCount)},
5569 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5570 Counter{cRestSubDelRespToXapp, 1},
5574 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5575 restSubId := xappConn1.SendRESTSubsReq(t, params)
5576 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5578 assert.Equal(t, len(e2SubsIds), subReqCount)
5581 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5582 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5584 xappConn1.TestMsgChanEmpty(t)
5585 e2termConn1.TestMsgChanEmpty(t)
5586 mainCtrl.wait_registry_empty(t, 10)
5588 mainCtrl.VerifyCounterValues(t)
5589 mainCtrl.VerifyAllClean(t)
5592 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
5596 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5597 Counter{cRestSubReqFromXapp, 1},
5598 Counter{cRestSubRespToXapp, 1},
5599 Counter{cSubReqToE2, uint64(subReqCount)},
5600 Counter{cSubRespFromE2, uint64(subReqCount)},
5601 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5602 Counter{cRestSubDelReqFromXapp, 1},
5603 Counter{cSubDelReqToE2, uint64(subReqCount)},
5604 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5605 Counter{cRestSubDelRespToXapp, 1},
5609 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5610 restSubId := xappConn1.SendRESTSubsReq(t, params)
5611 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5613 assert.Equal(t, len(e2SubsIds), subReqCount)
5616 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5617 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5619 xappConn1.TestMsgChanEmpty(t)
5620 e2termConn1.TestMsgChanEmpty(t)
5621 mainCtrl.wait_registry_empty(t, 10)
5623 mainCtrl.VerifyCounterValues(t)
5624 mainCtrl.VerifyAllClean(t)
5627 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
5628 CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
5630 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5631 Counter{cRestSubReqFromXapp, 2},
5632 Counter{cRestSubRespToXapp, 2},
5633 Counter{cSubReqToE2, 2},
5634 Counter{cSubRespFromE2, 2},
5635 Counter{cRestSubNotifToXapp, 2},
5636 Counter{cRestSubDelReqFromXapp, 2},
5637 Counter{cSubDelReqToE2, 2},
5638 Counter{cSubDelRespFromE2, 2},
5639 Counter{cRestSubDelRespToXapp, 2},
5643 var params *teststube2ap.RESTSubsReqParams = nil
5646 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5647 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5649 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5652 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5653 params.SetMeid("RAN_NAME_1")
5654 eventTriggerDefinition := []int64{1234, 1}
5655 params.SetSubEventTriggerDefinition(eventTriggerDefinition)
5657 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5658 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5659 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5660 xappConn2.ExpectRESTNotification(t, restSubId2)
5661 e2termConn1.SendSubsResp(t, crereq, cremsg)
5662 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5664 deleteXapp1Subscription(t, &restSubId1)
5665 deleteXapp2Subscription(t, &restSubId2)
5667 waitSubsCleanup(t, e2SubsId1, 10)
5668 waitSubsCleanup(t, e2SubsId2, 10)
5670 mainCtrl.VerifyCounterValues(t)
5671 mainCtrl.VerifyAllClean(t)
5674 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
5675 CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
5677 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5678 Counter{cRestSubReqFromXapp, 2},
5679 Counter{cRestSubRespToXapp, 2},
5680 Counter{cSubReqToE2, 2},
5681 Counter{cSubRespFromE2, 2},
5682 Counter{cRestSubNotifToXapp, 2},
5683 Counter{cRestSubDelReqFromXapp, 2},
5684 Counter{cSubDelReqToE2, 2},
5685 Counter{cSubDelRespFromE2, 2},
5686 Counter{cRestSubDelRespToXapp, 2},
5690 var params *teststube2ap.RESTSubsReqParams = nil
5693 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5694 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5696 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5699 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5700 params.SetMeid("RAN_NAME_1")
5702 actionId := int64(1)
5703 actionType := "report"
5704 actionDefinition := []int64{5678, 1}
5705 subsequestActionType := "continue"
5706 timeToWait := "w10ms"
5707 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
5709 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5710 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5711 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5712 xappConn2.ExpectRESTNotification(t, restSubId2)
5713 e2termConn1.SendSubsResp(t, crereq, cremsg)
5714 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5716 deleteXapp1Subscription(t, &restSubId1)
5717 deleteXapp2Subscription(t, &restSubId2)
5719 waitSubsCleanup(t, e2SubsId1, 10)
5720 waitSubsCleanup(t, e2SubsId2, 10)
5722 mainCtrl.VerifyCounterValues(t)
5723 mainCtrl.VerifyAllClean(t)
5726 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
5727 CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
5729 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5730 Counter{cRestSubReqFromXapp, 2},
5731 Counter{cRestSubRespToXapp, 2},
5732 Counter{cSubReqToE2, 2},
5733 Counter{cSubRespFromE2, 2},
5734 Counter{cRestSubNotifToXapp, 2},
5735 Counter{cRestSubDelReqFromXapp, 2},
5736 Counter{cSubDelReqToE2, 2},
5737 Counter{cSubDelRespFromE2, 2},
5738 Counter{cRestSubDelRespToXapp, 2},
5742 var params *teststube2ap.RESTSubsReqParams = nil
5745 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5746 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5748 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5751 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5752 params.SetMeid("RAN_NAME_1")
5753 params.SetSubActionIDs(int64(2))
5755 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5756 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5757 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5758 xappConn2.ExpectRESTNotification(t, restSubId2)
5759 e2termConn1.SendSubsResp(t, crereq, cremsg)
5760 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5762 deleteXapp1Subscription(t, &restSubId1)
5763 deleteXapp2Subscription(t, &restSubId2)
5765 waitSubsCleanup(t, e2SubsId1, 10)
5766 waitSubsCleanup(t, e2SubsId2, 10)
5768 mainCtrl.VerifyCounterValues(t)
5769 mainCtrl.VerifyAllClean(t)
5772 func TestRESTSubReqDiffActionType(t *testing.T) {
5773 CaseBegin("TestRESTSubReqDiffActionType")
5775 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5776 Counter{cRestSubReqFromXapp, 2},
5777 Counter{cRestSubRespToXapp, 2},
5778 Counter{cSubReqToE2, 2},
5779 Counter{cSubRespFromE2, 2},
5780 Counter{cRestSubNotifToXapp, 2},
5781 Counter{cRestSubDelReqFromXapp, 2},
5782 Counter{cSubDelReqToE2, 2},
5783 Counter{cSubDelRespFromE2, 2},
5784 Counter{cRestSubDelRespToXapp, 2},
5787 const e2Timeout int64 = 2
5788 const e2RetryCount int64 = 2
5789 const routingNeeded bool = true
5792 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5793 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5796 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5797 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5799 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5802 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5803 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5804 params.SetMeid("RAN_NAME_1")
5806 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5807 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5808 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5809 xappConn2.ExpectRESTNotification(t, restSubId2)
5810 e2termConn1.SendSubsResp(t, crereq, cremsg)
5811 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5813 deleteXapp1Subscription(t, &restSubId1)
5814 deleteXapp2Subscription(t, &restSubId2)
5816 waitSubsCleanup(t, e2SubsId1, 10)
5817 waitSubsCleanup(t, e2SubsId2, 10)
5819 mainCtrl.VerifyCounterValues(t)
5820 mainCtrl.VerifyAllClean(t)
5823 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
5824 CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
5826 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5827 Counter{cRestSubReqFromXapp, 2},
5828 Counter{cRestSubRespToXapp, 2},
5829 Counter{cSubReqToE2, 2},
5830 Counter{cSubRespFromE2, 2},
5831 Counter{cRestSubNotifToXapp, 2},
5832 Counter{cRestSubDelReqFromXapp, 2},
5833 Counter{cSubDelReqToE2, 2},
5834 Counter{cSubDelRespFromE2, 2},
5835 Counter{cRestSubDelRespToXapp, 2},
5838 const e2Timeout int64 = 2
5839 const e2RetryCount int64 = 2
5840 const routingNeeded bool = true
5843 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5844 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5847 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5848 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5850 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5853 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
5854 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5855 params.SetMeid("RAN_NAME_1")
5857 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5858 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5859 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5860 xappConn2.ExpectRESTNotification(t, restSubId2)
5861 e2termConn1.SendSubsResp(t, crereq, cremsg)
5862 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5864 deleteXapp1Subscription(t, &restSubId1)
5865 deleteXapp2Subscription(t, &restSubId2)
5867 waitSubsCleanup(t, e2SubsId1, 10)
5868 waitSubsCleanup(t, e2SubsId2, 10)
5870 mainCtrl.VerifyCounterValues(t)
5871 mainCtrl.VerifyAllClean(t)
5874 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
5875 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
5877 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5878 Counter{cRestSubReqFromXapp, 2},
5879 Counter{cRestSubRespToXapp, 2},
5880 Counter{cSubReqToE2, 2},
5881 Counter{cSubRespFromE2, 2},
5882 Counter{cRestSubNotifToXapp, 2},
5883 Counter{cRestSubDelReqFromXapp, 2},
5884 Counter{cSubDelReqToE2, 2},
5885 Counter{cSubDelRespFromE2, 2},
5886 Counter{cRestSubDelRespToXapp, 2},
5890 var params *teststube2ap.RESTSubsReqParams = nil
5893 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5894 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5896 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5899 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5900 params.SetMeid("RAN_NAME_1")
5901 actionDefinition := []int64{5678, 1}
5902 params.SetSubActionDefinition(actionDefinition)
5904 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5905 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5906 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5907 xappConn2.ExpectRESTNotification(t, restSubId2)
5908 e2termConn1.SendSubsResp(t, crereq, cremsg)
5909 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5911 deleteXapp1Subscription(t, &restSubId1)
5912 deleteXapp2Subscription(t, &restSubId2)
5914 waitSubsCleanup(t, e2SubsId1, 10)
5915 waitSubsCleanup(t, e2SubsId2, 10)
5917 mainCtrl.VerifyCounterValues(t)
5918 mainCtrl.VerifyAllClean(t)
5921 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
5922 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
5924 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5925 Counter{cRestSubReqFromXapp, 2},
5926 Counter{cRestSubRespToXapp, 2},
5927 Counter{cSubReqToE2, 2},
5928 Counter{cSubRespFromE2, 2},
5929 Counter{cRestSubNotifToXapp, 2},
5930 Counter{cRestSubDelReqFromXapp, 2},
5931 Counter{cSubDelReqToE2, 2},
5932 Counter{cSubDelRespFromE2, 2},
5933 Counter{cRestSubDelRespToXapp, 2},
5937 var params *teststube2ap.RESTSubsReqParams = nil
5940 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5941 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5943 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5946 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5947 params.SetMeid("RAN_NAME_1")
5948 actionDefinition := []int64{56782}
5949 params.SetSubActionDefinition(actionDefinition)
5951 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5952 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5953 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5954 xappConn2.ExpectRESTNotification(t, restSubId2)
5955 e2termConn1.SendSubsResp(t, crereq, cremsg)
5956 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5958 deleteXapp1Subscription(t, &restSubId1)
5959 deleteXapp2Subscription(t, &restSubId2)
5961 waitSubsCleanup(t, e2SubsId1, 10)
5962 waitSubsCleanup(t, e2SubsId2, 10)
5964 mainCtrl.VerifyCounterValues(t)
5965 mainCtrl.VerifyAllClean(t)
5968 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
5969 CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
5971 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5972 Counter{cRestSubReqFromXapp, 2},
5973 Counter{cRestSubRespToXapp, 2},
5974 Counter{cSubReqToE2, 2},
5975 Counter{cSubRespFromE2, 2},
5976 Counter{cRestSubNotifToXapp, 2},
5977 Counter{cRestSubDelReqFromXapp, 2},
5978 Counter{cSubDelReqToE2, 2},
5979 Counter{cSubDelRespFromE2, 2},
5980 Counter{cRestSubDelRespToXapp, 2},
5984 var params *teststube2ap.RESTSubsReqParams = nil
5987 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5988 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5990 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5993 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5994 params.SetMeid("RAN_NAME_1")
5995 params.SetTimeToWait("w200ms")
5996 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5997 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5998 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5999 xappConn2.ExpectRESTNotification(t, restSubId2)
6000 e2termConn1.SendSubsResp(t, crereq, cremsg)
6001 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
6003 deleteXapp1Subscription(t, &restSubId1)
6004 deleteXapp2Subscription(t, &restSubId2)
6006 waitSubsCleanup(t, e2SubsId1, 10)
6007 waitSubsCleanup(t, e2SubsId2, 10)
6009 mainCtrl.VerifyCounterValues(t)
6010 mainCtrl.VerifyAllClean(t)
6013 //-----------------------------------------------------------------------------
6014 // TestRESTUnpackSubscriptionResponseDecodeFail
6017 // +-------+ +---------+ +---------+
6018 // | xapp | | submgr | | e2term |
6019 // +-------+ +---------+ +---------+
6022 // |---------------->| |
6024 // | RESTSubResp | |
6025 // |<----------------| |
6028 // | |------------->|
6030 // | | SubResp | ASN.1 decode fails
6031 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
6034 // | |------------->|
6036 // | | SubFail | Duplicated action
6037 // | |<-------------|
6038 // | RESTNotif (fail)| |
6039 // |<----------------| |
6041 // | [SUBS DELETE] |
6044 //-----------------------------------------------------------------------------
6046 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
6047 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
6049 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6050 Counter{cRestSubReqFromXapp, 1},
6051 Counter{cRestSubRespToXapp, 1},
6052 Counter{cSubReqToE2, 1},
6053 Counter{cSubReqTimerExpiry, 1},
6054 Counter{cSubReReqToE2, 1},
6055 Counter{cSubRespFromE2, 1},
6056 Counter{cSubFailFromE2, 1},
6057 Counter{cRestSubFailNotifToXapp, 1},
6058 Counter{cRestSubDelReqFromXapp, 1},
6059 Counter{cRestSubDelRespToXapp, 1},
6062 const subReqCount int = 1
6065 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6066 restSubId := xappConn1.SendRESTSubsReq(t, params)
6068 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6069 // Decode of this response fails which will result resending original request
6070 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
6072 _, cremsg = e2termConn1.RecvSubsReq(t)
6074 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6076 // Subscription already created in E2 Node.
6077 fparams := &teststube2ap.E2StubSubsFailParams{}
6079 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6080 e2termConn1.SendSubsFail(t, fparams, cremsg)
6082 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6083 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6085 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6087 // Wait that subs is cleaned
6088 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6090 xappConn1.TestMsgChanEmpty(t)
6091 e2termConn1.TestMsgChanEmpty(t)
6092 mainCtrl.wait_registry_empty(t, 10)
6093 mainCtrl.VerifyAllClean(t)
6094 mainCtrl.VerifyCounterValues(t)
6097 //-----------------------------------------------------------------------------
6098 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
6101 // +-------+ +---------+ +---------+
6102 // | xapp | | submgr | | e2term |
6103 // +-------+ +---------+ +---------+
6106 // |---------------->| |
6108 // | RESTSubResp | |
6109 // |<----------------| |
6112 // | |------------->|
6114 // | | SubResp | Unknown instanceId
6115 // | |<-------------| No valid subscription found with subIds [0]
6118 // | |------------->|
6120 // | | SubFail | Duplicated action
6121 // | |<-------------| No valid subscription found with subIds [0]
6122 // | RESTNotif (fail)| |
6123 // |<----------------| |
6125 // | |------------->|
6128 // | |<-------------|
6130 // | [SUBS DELETE] |
6133 //-----------------------------------------------------------------------------
6135 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
6136 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
6138 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6139 Counter{cRestSubReqFromXapp, 1},
6140 Counter{cRestSubRespToXapp, 1},
6141 Counter{cSubReqToE2, 1},
6142 Counter{cSubReqTimerExpiry, 2},
6143 Counter{cSubReReqToE2, 1},
6144 Counter{cSubRespFromE2, 1},
6145 Counter{cSubFailFromE2, 1},
6146 Counter{cRestSubFailNotifToXapp, 1},
6147 Counter{cRestSubDelReqFromXapp, 1},
6148 Counter{cRestSubDelRespToXapp, 1},
6149 Counter{cSubDelReqToE2, 1},
6150 Counter{cSubDelRespFromE2, 1},
6153 const subReqCount int = 1
6156 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6157 restSubId := xappConn1.SendRESTSubsReq(t, params)
6159 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6161 // Unknown instanceId 0 in this response which will result resending original request
6162 orgInstanceId := crereq.RequestId.InstanceId
6163 crereq.RequestId.InstanceId = 0
6164 e2termConn1.SendSubsResp(t, crereq, cremsg)
6166 _, cremsg = e2termConn1.RecvSubsReq(t)
6168 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6170 // Subscription already created in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
6171 fparams := &teststube2ap.E2StubSubsFailParams{}
6173 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6174 e2termConn1.SendSubsFail(t, fparams, cremsg)
6176 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6177 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6179 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6180 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6182 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6184 // Wait that subs is cleaned
6185 mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
6187 xappConn1.TestMsgChanEmpty(t)
6188 e2termConn1.TestMsgChanEmpty(t)
6189 mainCtrl.wait_registry_empty(t, 10)
6190 mainCtrl.VerifyAllClean(t)
6191 mainCtrl.VerifyCounterValues(t)
6194 //-----------------------------------------------------------------------------
6195 // TestRESTUnpackSubscriptionResponseNoTransaction
6198 // +-------+ +---------+ +---------+
6199 // | xapp | | submgr | | e2term |
6200 // +-------+ +---------+ +---------+
6203 // |---------------->| |
6205 // | RESTSubResp | |
6206 // |<----------------| |
6209 // | |------------->|
6211 // | | SubResp | No transaction for the response
6212 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
6215 // | |------------->|
6217 // | | SubFail | Duplicated action
6218 // | |<-------------|Ongoing transaction not found. This will result timer expiry and sending delete
6219 // | RESTNotif (fail)| |
6220 // |<----------------| |
6222 // | |------------->|
6225 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
6228 // | |------------->|
6231 // | |<-------------| Ongoing transaction not found.
6233 // | [SUBS DELETE] |
6236 //-----------------------------------------------------------------------------
6237 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
6238 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
6240 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6241 Counter{cRestSubReqFromXapp, 1},
6242 Counter{cRestSubRespToXapp, 1},
6243 Counter{cSubReqToE2, 1},
6244 Counter{cSubReqTimerExpiry, 2},
6245 Counter{cSubReReqToE2, 1},
6246 Counter{cSubRespFromE2, 1},
6247 Counter{cSubFailFromE2, 1},
6248 Counter{cRestSubFailNotifToXapp, 1},
6249 Counter{cRestSubDelReqFromXapp, 1},
6250 Counter{cRestSubDelRespToXapp, 1},
6251 Counter{cSubDelReqToE2, 1},
6252 Counter{cSubDelReqTimerExpiry, 2},
6253 Counter{cSubDelReReqToE2, 1},
6254 Counter{cSubDelRespFromE2, 2},
6257 const subReqCount int = 1
6260 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6261 restSubId := xappConn1.SendRESTSubsReq(t, params)
6263 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6265 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6266 // No transaction exist for this response which will result resending original request
6267 e2termConn1.SendSubsResp(t, crereq, cremsg)
6269 _, cremsg = e2termConn1.RecvSubsReq(t)
6271 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6273 // Subscription already created in E2 Node.
6274 fparams := &teststube2ap.E2StubSubsFailParams{}
6276 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6277 e2termConn1.SendSubsFail(t, fparams, cremsg)
6279 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6280 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6282 // Resending happens because there no transaction
6283 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6284 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6286 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6287 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6289 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6291 // Wait that subs is cleaned
6292 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6294 xappConn1.TestMsgChanEmpty(t)
6295 e2termConn1.TestMsgChanEmpty(t)
6296 mainCtrl.wait_registry_empty(t, 10)
6297 mainCtrl.VerifyAllClean(t)
6298 mainCtrl.VerifyCounterValues(t)
6301 //-----------------------------------------------------------------------------
6302 // TestRESTUnpackSubscriptionFailureDecodeFail
6305 // +-------+ +---------+ +---------+
6306 // | xapp | | submgr | | e2term |
6307 // +-------+ +---------+ +---------+
6310 // |---------------->| |
6312 // | RESTSubResp | |
6313 // |<----------------| |
6316 // | |------------->|
6318 // | | SubFail | ASN.1 decode fails
6319 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
6322 // | |------------->|
6324 // | | SubFail | Duplicated action
6325 // | |<-------------|
6326 // | RESTNotif (fail)| |
6327 // |<----------------| |
6329 // | [SUBS DELETE] |
6332 //-----------------------------------------------------------------------------
6333 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
6334 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
6336 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6337 Counter{cRestSubReqFromXapp, 1},
6338 Counter{cRestSubRespToXapp, 1},
6339 Counter{cSubReqToE2, 1},
6340 Counter{cSubReqTimerExpiry, 1},
6341 Counter{cSubReReqToE2, 1},
6342 Counter{cSubFailFromE2, 2},
6343 Counter{cRestSubFailNotifToXapp, 1},
6344 Counter{cRestSubDelReqFromXapp, 1},
6345 Counter{cRestSubDelRespToXapp, 1},
6348 const subReqCount int = 1
6351 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6352 restSubId := xappConn1.SendRESTSubsReq(t, params)
6354 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6356 // Decode of this response fails which will result resending original request
6357 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
6359 _, cremsg = e2termConn1.RecvSubsReq(t)
6361 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6363 // Subscription already created in E2 Node.
6364 fparams := &teststube2ap.E2StubSubsFailParams{}
6366 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6367 e2termConn1.SendSubsFail(t, fparams, cremsg)
6369 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6370 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6372 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6374 // Wait that subs is cleaned
6375 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6377 xappConn1.TestMsgChanEmpty(t)
6378 e2termConn1.TestMsgChanEmpty(t)
6379 mainCtrl.wait_registry_empty(t, 10)
6380 mainCtrl.VerifyAllClean(t)
6381 mainCtrl.VerifyCounterValues(t)
6384 //-----------------------------------------------------------------------------
6385 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
6388 // +-------+ +---------+ +---------+
6389 // | xapp | | submgr | | e2term |
6390 // +-------+ +---------+ +---------+
6393 // |---------------->| |
6395 // | RESTSubResp | |
6396 // |<----------------| |
6399 // | |------------->|
6401 // | | SubFail | Unknown instanceId
6402 // | |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
6405 // | |------------->|
6407 // | | SubFail | Duplicated action
6408 // | |<-------------|No valid subscription found with subIds [0]. This will result timer expiry and sending delete
6409 // | RESTNotif (fail)| |
6410 // |<----------------| |
6412 // | |------------->|
6415 // | |<-------------|
6417 // | [SUBS DELETE] |
6420 //-----------------------------------------------------------------------------
6421 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
6422 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
6423 const subReqCount int = 1
6425 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6426 Counter{cRestSubReqFromXapp, 1},
6427 Counter{cRestSubRespToXapp, 1},
6428 Counter{cSubReqToE2, 1},
6429 Counter{cSubReqTimerExpiry, 2},
6430 Counter{cSubReReqToE2, 1},
6431 Counter{cSubFailFromE2, 2},
6432 Counter{cRestSubFailNotifToXapp, 1},
6433 Counter{cRestSubDelReqFromXapp, 1},
6434 Counter{cRestSubDelRespToXapp, 1},
6435 Counter{cSubDelReqToE2, 1},
6436 Counter{cSubDelRespFromE2, 1},
6440 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6441 restSubId := xappConn1.SendRESTSubsReq(t, params)
6443 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6445 // Unknown instanceId 0 in this response which will result resending original request
6446 fparams := &teststube2ap.E2StubSubsFailParams{}
6448 fparams.Fail.RequestId.InstanceId = 0
6449 e2termConn1.SendSubsFail(t, fparams, cremsg)
6451 _, cremsg = e2termConn1.RecvSubsReq(t)
6453 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6455 // Subscription already created in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
6456 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6457 e2termConn1.SendSubsFail(t, fparams, cremsg)
6459 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6460 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6462 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6463 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6465 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6467 // Wait that subs is cleaned
6468 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6470 xappConn1.TestMsgChanEmpty(t)
6471 e2termConn1.TestMsgChanEmpty(t)
6472 mainCtrl.wait_registry_empty(t, 10)
6473 mainCtrl.VerifyAllClean(t)
6474 mainCtrl.VerifyCounterValues(t)
6477 //-----------------------------------------------------------------------------
6478 // TestRESTUnpackSubscriptionFailureNoTransaction
6481 // +-------+ +---------+ +---------+
6482 // | xapp | | submgr | | e2term |
6483 // +-------+ +---------+ +---------+
6486 // |---------------->| |
6488 // | RESTSubResp | |
6489 // |<----------------| |
6492 // | |------------->|
6494 // | | SubFail | No transaction for the response
6495 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
6498 // | |------------->|
6500 // | | SubFail | Duplicated action
6501 // | |<-------------| Ongoing transaction not found. This will result timer expiry and sending delete
6502 // | RESTNotif (fail)| |
6503 // |<----------------| |
6505 // | |------------->|
6508 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
6511 // | |------------->|
6514 // | |<-------------| Ongoing transaction not found.
6516 // | [SUBS DELETE] |
6519 //-----------------------------------------------------------------------------
6520 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
6521 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
6522 const subReqCount int = 1
6524 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6525 Counter{cRestSubReqFromXapp, 1},
6526 Counter{cRestSubRespToXapp, 1},
6527 Counter{cSubReqToE2, 1},
6528 Counter{cSubReqTimerExpiry, 2},
6529 Counter{cSubReReqToE2, 1},
6530 Counter{cSubFailFromE2, 2},
6531 Counter{cRestSubFailNotifToXapp, 1},
6532 Counter{cRestSubDelReqFromXapp, 1},
6533 Counter{cRestSubDelRespToXapp, 1},
6534 Counter{cSubDelReqToE2, 1},
6535 Counter{cSubDelReqTimerExpiry, 2},
6536 Counter{cSubDelReReqToE2, 1},
6537 Counter{cSubDelRespFromE2, 2},
6541 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6542 restSubId := xappConn1.SendRESTSubsReq(t, params)
6544 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6546 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6548 // No transaction exist for this response which will result resending original request
6549 fparams := &teststube2ap.E2StubSubsFailParams{}
6551 e2termConn1.SendSubsFail(t, fparams, cremsg)
6553 _, cremsg = e2termConn1.RecvSubsReq(t)
6555 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6557 // Subscription already created in E2 Node.
6558 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6559 e2termConn1.SendSubsFail(t, fparams, cremsg)
6561 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6562 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6564 // Resending happens because there no transaction
6565 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6566 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6568 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6569 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6571 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6573 // Wait that subs is cleaned
6574 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6576 xappConn1.TestMsgChanEmpty(t)
6577 e2termConn1.TestMsgChanEmpty(t)
6578 mainCtrl.wait_registry_empty(t, 10)
6579 mainCtrl.VerifyAllClean(t)
6580 mainCtrl.VerifyCounterValues(t)
6583 //-----------------------------------------------------------------------------
6584 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
6587 // +-------+ +---------+ +---------+
6588 // | xapp | | submgr | | e2term |
6589 // +-------+ +---------+ +---------+
6591 // | [SUBS CREATE] |
6594 // | RESTSubDelReq | |
6595 // |---------------->| |
6597 // | RESTSubDelResp | |
6598 // |<----------------| |
6601 // | |------------->|
6603 // | | SubDelResp | ASN.1 decode fails.
6604 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
6607 // | |------------->|
6609 // | | SubDelFail | Subscription does exist any more in E2 node
6610 // | |<-------------|
6612 // | [SUBS DELETE] |
6615 //-----------------------------------------------------------------------------
6616 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
6617 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail")
6619 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6620 Counter{cRestSubReqFromXapp, 1},
6621 Counter{cRestSubRespToXapp, 1},
6622 Counter{cSubReqToE2, 1},
6623 Counter{cSubRespFromE2, 1},
6624 Counter{cRestSubNotifToXapp, 1},
6625 Counter{cRestSubDelReqFromXapp, 1},
6626 Counter{cRestSubDelRespToXapp, 1},
6627 Counter{cSubDelReqToE2, 1},
6628 Counter{cSubDelReqTimerExpiry, 1},
6629 Counter{cSubDelReReqToE2, 1},
6630 Counter{cSubDelFailFromE2, 1},
6631 Counter{cSubDelRespFromE2, 1},
6635 var params *teststube2ap.RESTSubsReqParams = nil
6636 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6639 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6641 // E2t: Receive 1st SubsDelReq
6642 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6644 // Decode of this response fails which will result resending original request
6645 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_RESP)
6647 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6648 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6650 // Subscription does not exist in in E2 Node.
6651 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6653 // Wait that subs is cleaned
6654 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6656 xappConn1.TestMsgChanEmpty(t)
6657 e2termConn1.TestMsgChanEmpty(t)
6658 mainCtrl.wait_registry_empty(t, 10)
6659 mainCtrl.VerifyAllClean(t)
6660 mainCtrl.VerifyCounterValues(t)
6663 //-----------------------------------------------------------------------------
6664 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
6667 // +-------+ +---------+ +---------+
6668 // | xapp | | submgr | | e2term |
6669 // +-------+ +---------+ +---------+
6671 // | [SUBS CREATE] |
6674 // | RESTSubDelReq | |
6675 // |---------------->| |
6677 // | RESTSubDelResp | |
6678 // |<----------------| |
6681 // | |------------->|
6683 // | | SubDelResp | Unknown instanceId
6684 // | |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
6687 // | |------------->|
6689 // | | SubDelFail | Subscription does exist any more in E2 node
6690 // | |<-------------|
6692 // | [SUBS DELETE] |
6694 //-----------------------------------------------------------------------------
6695 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
6696 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId")
6698 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6699 Counter{cRestSubReqFromXapp, 1},
6700 Counter{cRestSubRespToXapp, 1},
6701 Counter{cSubReqToE2, 1},
6702 Counter{cSubRespFromE2, 1},
6703 Counter{cRestSubNotifToXapp, 1},
6704 Counter{cRestSubDelReqFromXapp, 1},
6705 Counter{cRestSubDelRespToXapp, 1},
6706 Counter{cSubDelReqToE2, 1},
6707 Counter{cSubDelReqTimerExpiry, 1},
6708 Counter{cSubDelReReqToE2, 1},
6709 Counter{cSubDelRespFromE2, 1},
6710 Counter{cSubDelFailFromE2, 1},
6714 var params *teststube2ap.RESTSubsReqParams = nil
6715 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6718 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6720 // E2t: Receive 1st SubsDelReq
6721 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6723 // Unknown instanceId in this response which will result resending original request
6724 delreq.RequestId.InstanceId = 0
6725 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6727 // E2t: Receive 2nd SubsDelReq
6728 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6730 // Subscription does not exist in in E2 Node.
6731 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6733 // Wait that subs is cleaned
6734 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6736 xappConn1.TestMsgChanEmpty(t)
6737 e2termConn1.TestMsgChanEmpty(t)
6738 mainCtrl.wait_registry_empty(t, 10)
6739 mainCtrl.VerifyAllClean(t)
6740 mainCtrl.VerifyCounterValues(t)
6743 //-----------------------------------------------------------------------------
6744 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
6747 // +-------+ +---------+ +---------+
6748 // | xapp | | submgr | | e2term |
6749 // +-------+ +---------+ +---------+
6751 // | [SUBS CREATE] |
6754 // | RESTSubDelReq | |
6755 // |---------------->| |
6757 // | RESTSubDelResp | |
6758 // |<----------------| |
6761 // | |------------->|
6763 // | | SubDelResp | No transaction for the response
6764 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
6767 // | |------------->|
6769 // | | SubDelFail | Subscription does exist any more in E2 node
6770 // | |<-------------| Ongoing transaction not found. This will result timer expiry
6772 // | [SUBS DELETE] |
6774 //-----------------------------------------------------------------------------
6775 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
6776 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction")
6778 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6779 Counter{cRestSubReqFromXapp, 1},
6780 Counter{cRestSubRespToXapp, 1},
6781 Counter{cSubReqToE2, 1},
6782 Counter{cSubRespFromE2, 1},
6783 Counter{cRestSubNotifToXapp, 1},
6784 Counter{cRestSubDelReqFromXapp, 1},
6785 Counter{cRestSubDelRespToXapp, 1},
6786 Counter{cSubDelReqToE2, 1},
6787 Counter{cSubDelReqTimerExpiry, 2},
6788 Counter{cSubDelReReqToE2, 1},
6789 Counter{cSubDelRespFromE2, 1},
6790 Counter{cSubDelFailFromE2, 1},
6794 var params *teststube2ap.RESTSubsReqParams = nil
6795 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6798 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6800 // E2t: Receive 1st SubsDelReq
6801 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6803 mainCtrl.MakeTransactionNil(t, e2SubsId)
6805 // No transaction exist for this response which will result resending original request
6806 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6808 // E2t: Receive 2nd SubsDelReq
6809 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6811 // Subscription does not exist in in E2 Node.
6812 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6814 // Wait that subs is cleaned
6815 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6817 xappConn1.TestMsgChanEmpty(t)
6818 e2termConn1.TestMsgChanEmpty(t)
6819 mainCtrl.wait_registry_empty(t, 10)
6820 mainCtrl.VerifyAllClean(t)
6821 mainCtrl.VerifyCounterValues(t)
6824 //-----------------------------------------------------------------------------
6825 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
6828 // +-------+ +---------+ +---------+
6829 // | xapp | | submgr | | e2term |
6830 // +-------+ +---------+ +---------+
6832 // | [SUBS CREATE] |
6835 // | RESTSubDelReq | |
6836 // |---------------->| |
6838 // | RESTSubDelResp | |
6839 // |<----------------| |
6842 // | |------------->|
6844 // | | SubDelFail | ASN.1 decode fails
6845 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
6848 // | |------------->|
6850 // | | SubDelFail | Subscription does exist any more in E2 node
6851 // | |<-------------|
6853 // | [SUBS DELETE] |
6855 //-----------------------------------------------------------------------------
6856 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
6857 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail")
6859 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6860 Counter{cRestSubReqFromXapp, 1},
6861 Counter{cRestSubRespToXapp, 1},
6862 Counter{cSubReqToE2, 1},
6863 Counter{cSubRespFromE2, 1},
6864 Counter{cRestSubNotifToXapp, 1},
6865 Counter{cRestSubDelReqFromXapp, 1},
6866 Counter{cRestSubDelRespToXapp, 1},
6867 Counter{cSubDelReqToE2, 1},
6868 Counter{cSubDelReqTimerExpiry, 1},
6869 Counter{cSubDelReReqToE2, 1},
6870 Counter{cSubDelFailFromE2, 2},
6874 var params *teststube2ap.RESTSubsReqParams = nil
6875 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6878 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6880 // E2t: Receive 1st SubsDelReq
6881 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6883 // Decode of this response fails which will result resending original request
6884 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
6886 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6887 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6889 // Subscription does not exist in in E2 Node.
6890 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6892 // Wait that subs is cleaned
6893 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6895 xappConn1.TestMsgChanEmpty(t)
6896 e2termConn1.TestMsgChanEmpty(t)
6897 mainCtrl.wait_registry_empty(t, 10)
6898 mainCtrl.VerifyAllClean(t)
6899 mainCtrl.VerifyCounterValues(t)
6902 //-----------------------------------------------------------------------------
6903 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
6906 // +-------+ +---------+ +---------+
6907 // | xapp | | submgr | | e2term |
6908 // +-------+ +---------+ +---------+
6910 // | [SUBS CREATE] |
6913 // | RESTSubDelReq | |
6914 // |---------------->| |
6916 // | RESTSubDelResp | |
6917 // |<----------------| |
6920 // | |------------->|
6922 // | | SubDelFail | Unknown instanceId
6923 // | |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
6926 // | |------------->|
6928 // | | SubDelFail | Subscription does exist any more in E2 node
6929 // | |<-------------| No valid subscription found with subIds [0].
6931 // | [SUBS DELETE] |
6933 //-----------------------------------------------------------------------------
6934 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
6935 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId")
6937 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6938 Counter{cRestSubReqFromXapp, 1},
6939 Counter{cRestSubRespToXapp, 1},
6940 Counter{cSubReqToE2, 1},
6941 Counter{cSubRespFromE2, 1},
6942 Counter{cRestSubNotifToXapp, 1},
6943 Counter{cRestSubDelReqFromXapp, 1},
6944 Counter{cRestSubDelRespToXapp, 1},
6945 Counter{cSubDelReqToE2, 1},
6946 Counter{cSubDelReqTimerExpiry, 1},
6947 Counter{cSubDelReReqToE2, 1},
6948 Counter{cSubDelFailFromE2, 2},
6952 var params *teststube2ap.RESTSubsReqParams = nil
6953 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6956 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6958 // E2t: Receive 1st SubsDelReq
6959 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6961 // Unknown instanceId 0 in this response which will result resending original request
6962 delreq.RequestId.InstanceId = 0
6963 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6965 // E2t: Receive 2nd SubsDelReq
6966 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6968 // Subscription does not exist in in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
6969 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6971 // Wait that subs is cleaned
6972 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6974 xappConn1.TestMsgChanEmpty(t)
6975 e2termConn1.TestMsgChanEmpty(t)
6976 mainCtrl.wait_registry_empty(t, 10)
6977 mainCtrl.VerifyAllClean(t)
6978 mainCtrl.VerifyCounterValues(t)
6981 //-----------------------------------------------------------------------------
6982 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
6985 // +-------+ +---------+ +---------+
6986 // | xapp | | submgr | | e2term |
6987 // +-------+ +---------+ +---------+
6989 // | [SUBS CREATE] |
6992 // | RESTSubDelReq | |
6993 // |---------------->| |
6995 // | RESTSubDelResp | |
6996 // |<----------------| |
6999 // | |------------->|
7001 // | | SubDelFail | No transaction for the response
7002 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
7005 // | |------------->|
7007 // | | SubDelFail | Subscription does exist any more in E2 node
7008 // | |<-------------| Ongoing transaction not found. This will result timer expiry
7010 // | [SUBS DELETE] |
7012 //-----------------------------------------------------------------------------
7013 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
7014 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction")
7016 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7017 Counter{cRestSubReqFromXapp, 1},
7018 Counter{cRestSubRespToXapp, 1},
7019 Counter{cSubReqToE2, 1},
7020 Counter{cSubRespFromE2, 1},
7021 Counter{cRestSubNotifToXapp, 1},
7022 Counter{cRestSubDelReqFromXapp, 1},
7023 Counter{cRestSubDelRespToXapp, 1},
7024 Counter{cSubDelReqToE2, 1},
7025 Counter{cSubDelReqTimerExpiry, 2},
7026 Counter{cSubDelReReqToE2, 1},
7027 Counter{cSubDelFailFromE2, 2},
7031 var params *teststube2ap.RESTSubsReqParams = nil
7032 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
7035 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7037 // E2t: Receive 1st SubsDelReq
7038 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7040 mainCtrl.MakeTransactionNil(t, e2SubsId)
7042 // No transaction exist for this response which will result resending original request
7043 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
7045 // E2t: Receive 2nd SubsDelReq
7046 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
7048 // Subscription does not exist in in E2 Node.
7049 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
7051 // Wait that subs is cleaned
7052 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
7054 xappConn1.TestMsgChanEmpty(t)
7055 e2termConn1.TestMsgChanEmpty(t)
7056 mainCtrl.wait_registry_empty(t, 10)
7057 mainCtrl.VerifyAllClean(t)
7058 mainCtrl.VerifyCounterValues(t)
7061 //-----------------------------------------------------------------------------
7062 // TestRESTSubReqFailAsn1PackSubReqError
7065 // +-------+ +---------+ +---------+
7066 // | xapp | | submgr | | e2term |
7067 // +-------+ +---------+ +---------+
7070 // |---------------->| |
7072 // | RESTSubResp | |
7073 // |<----------------| |
7075 // | ASN.1 encode fails |
7078 // | |------------->|
7081 // | |<-------------|
7085 // |<----------------| |
7087 // | [SUBS DELETE] |
7090 //-----------------------------------------------------------------------------
7091 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
7093 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7094 Counter{cRestSubReqFromXapp, 1},
7095 Counter{cRestSubRespToXapp, 1},
7096 Counter{cRestSubFailNotifToXapp, 1},
7097 Counter{cRestSubDelReqFromXapp, 1},
7098 Counter{cRestSubDelRespToXapp, 1},
7101 const subReqCount int = 1
7103 var params *teststube2ap.RESTSubsReqParams = nil
7104 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
7105 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
7108 restSubId := xappConn1.SendRESTSubsReq(t, params)
7109 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
7111 // E2t: Receive SubsDelReq
7112 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7114 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7115 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
7117 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
7119 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7121 // Wait that subs is cleaned
7122 waitSubsCleanup(t, e2SubsId, 10)
7123 mainCtrl.VerifyAllClean(t)
7124 mainCtrl.VerifyCounterValues(t)
7127 func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
7128 CaseBegin("TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction")
7130 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7131 Counter{cRestSubReqFromXapp, 2},
7132 Counter{cRestSubRespToXapp, 2},
7133 Counter{cSubReqToE2, 2},
7134 Counter{cSubReqTimerExpiry, 1},
7135 Counter{cSubRespFromE2, 1},
7136 Counter{cRestSubNotifToXapp, 1},
7137 Counter{cRestSubFailNotifToXapp, 1},
7138 Counter{cRestSubDelReqFromXapp, 1},
7139 Counter{cSubDelReqToE2, 1},
7140 Counter{cSubDelRespFromE2, 1},
7141 Counter{cRestSubDelRespToXapp, 1},
7144 const e2Timeout int64 = 1
7145 const e2RetryCount int64 = 0
7146 const routingNeeded bool = false
7149 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7150 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7153 restSubId := xappConn1.SendRESTSubsReq(t, params)
7154 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
7156 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7157 xappConn1.ExpectRESTNotification(t, restSubId)
7158 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
7159 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7160 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7163 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7164 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7165 params.SetSubscriptionID(&restSubId)
7166 params.SetTimeToWait("w200ms")
7167 restSubId = xappConn1.SendRESTSubsReq(t, params)
7168 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
7170 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
7171 xappConn1.ExpectRESTNotification(t, restSubId)
7172 // SubsResp is missing, e2SubsId will be 0
7173 zeroE2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7174 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", zeroE2SubsId)
7177 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7178 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7179 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7181 waitSubsCleanup(t, e2SubsId, 10)
7182 mainCtrl.VerifyAllClean(t)
7183 mainCtrl.VerifyCounterValues(t)
7186 //-----------------------------------------------------------------------------
7187 // TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle
7190 // +-------+ +---------+ +---------+
7191 // | xapp | | submgr | | e2term |
7192 // +-------+ +---------+ +---------+
7195 // |---------------->| |
7197 // | RESTSubResp | |
7198 // |<----------------| |
7200 // | |------------->|
7203 // | |<-------------|
7206 // |<----------------| |
7209 // |---------------->| |
7211 // | RESTSubResp | |
7212 // |<----------------| |
7214 // | |------------->|
7216 // | Submgr restart |
7218 // | RESTSubDelReq | |
7219 // |---------------->| |
7222 // | |------------->|
7225 // | |<-------------|
7227 // | RESTSubDelResp | |
7228 // |<----------------| |
7230 //-----------------------------------------------------------------------------
7232 func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
7233 CaseBegin("TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle")
7235 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7236 Counter{cRestSubReqFromXapp, 2},
7237 Counter{cRestSubRespToXapp, 2},
7238 Counter{cSubReqToE2, 2},
7239 Counter{cSubRespFromE2, 1},
7240 Counter{cRestSubNotifToXapp, 1},
7241 Counter{cRestSubDelReqFromXapp, 1},
7242 Counter{cSubDelReqToE2, 1},
7243 Counter{cSubDelRespFromE2, 1},
7244 Counter{cRestSubDelRespToXapp, 1},
7247 const e2Timeout int64 = 1
7248 const e2RetryCount int64 = 0
7249 const routingNeeded bool = false
7252 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7253 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7254 // Create subscription
7255 restSubId := xappConn1.SendRESTSubsReq(t, params)
7256 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
7258 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7259 xappConn1.ExpectRESTNotification(t, restSubId)
7260 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
7261 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7262 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7264 // Check subscription
7265 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
7268 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7269 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7270 params.SetSubscriptionID(&restSubId)
7271 params.SetTimeToWait("w200ms")
7272 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
7273 restSubId = xappConn1.SendRESTSubsReq(t, params)
7274 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
7276 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
7277 mainCtrl.SetResetTestFlag(t, false)
7279 // SubsResp is missing due to submgr restart
7281 mainCtrl.SimulateRestart(t)
7282 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
7284 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
7285 // That needs to be completed before successful subscription query is possible
7286 <-time.After(time.Second * 1)
7288 // Check subscription
7289 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
7291 // Delete subscription
7292 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7293 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7294 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7296 //Wait that subs is cleaned
7297 waitSubsCleanup(t, e2SubsId, 10)
7299 mainCtrl.VerifyCounterValues(t)
7300 mainCtrl.VerifyAllClean(t)
7303 ////////////////////////////////////////////////////////////////////////////////////
7304 // Services for UT cases
7305 ////////////////////////////////////////////////////////////////////////////////////
7306 const subReqCount int = 1
7307 const host string = "localhost"
7309 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
7311 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
7313 restSubId := fromXappConn.SendRESTSubsReq(t, params)
7314 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
7316 crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
7317 fromXappConn.ExpectRESTNotification(t, restSubId)
7318 toE2termConn.SendSubsResp(t, crereq1, cremsg1)
7319 e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
7320 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7322 return restSubId, e2SubsId
7325 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
7327 params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
7329 params.SetMeid(meid)
7331 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
7332 restSubId := xappConn2.SendRESTSubsReq(t, params)
7333 xappConn2.ExpectRESTNotification(t, restSubId)
7334 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
7335 e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
7336 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7338 return restSubId, e2SubsId
7341 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
7343 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7344 restSubId := xappConn1.SendRESTSubsReq(t, params)
7345 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
7347 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7348 xappConn1.ExpectRESTNotification(t, restSubId)
7349 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
7350 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7351 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7353 return restSubId, e2SubsId
7356 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
7357 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7358 restSubId := xappConn1.SendRESTSubsReq(t, params)
7360 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7361 fparams1 := &teststube2ap.E2StubSubsFailParams{}
7362 fparams1.Set(crereq1)
7363 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
7365 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
7366 xappConn1.ExpectRESTNotification(t, restSubId)
7367 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
7368 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7369 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
7371 return restSubId, e2SubsId
7374 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
7375 fromXappConn.SendRESTSubsDelReq(t, restSubId)
7376 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
7377 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
7380 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
7381 xappConn1.SendRESTSubsDelReq(t, restSubId)
7382 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7383 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7386 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
7387 xappConn2.SendRESTSubsDelReq(t, restSubId)
7388 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7389 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7392 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
7393 resp, _ := xapp.Subscription.QuerySubscriptions()
7394 assert.Equal(t, e2SubsId, resp[0].SubscriptionID)
7395 assert.Equal(t, meid, resp[0].Meid)
7396 assert.Equal(t, endpoint, resp[0].ClientEndpoint)
7399 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
7400 //Wait that subs is cleaned
7401 mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
7403 xappConn1.TestMsgChanEmpty(t)
7404 xappConn2.TestMsgChanEmpty(t)
7405 e2termConn1.TestMsgChanEmpty(t)
7406 mainCtrl.wait_registry_empty(t, timeout)
7409 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
7411 var e2SubsId []uint32
7413 for i := 0; i < count; i++ {
7414 xapp.Logger.Debug("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
7415 crereq, cremsg := toE2termConn.RecvSubsReq(t)
7416 fromXappConn.ExpectRESTNotification(t, restSubId)
7417 toE2termConn.SendSubsResp(t, crereq, cremsg)
7418 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
7419 e2SubsId = append(e2SubsId, instanceId)
7420 xapp.Logger.Debug("TEST: %v", e2SubsId)
7421 xapp.Logger.Debug("TEST: %d ===================================== END CRE ============================================", i+1)
7422 <-time.After(100 * time.Millisecond)
7427 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
7429 for i := 0; i < len(e2SubsIds); i++ {
7430 xapp.Logger.Debug("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
7431 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
7432 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
7433 <-time.After(1 * time.Second)
7434 xapp.Logger.Debug("TEST: %d ===================================== END DEL ============================================", i+1)
7435 <-time.After(100 * time.Millisecond)
7438 // Wait that subs is cleaned
7439 for i := 0; i < len(e2SubsIds); i++ {
7440 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)