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)
679 mainCtrl.VerifyCounterValues(t)
682 //-----------------------------------------------------------------------------
683 // TestSubMergeDelAndRouteUpdateNok
685 // +-------+ +-------+ +---------+ +---------+
686 // | xapp2 | | xapp1 | | submgr | | e2term |
687 // +-------+ +-------+ +---------+ +---------+
692 // | |------------->| |
695 // | | |------------->|
697 // | | |<-------------|
699 // | |<-------------| |
702 // |--------------------------->| |
705 // |<---------------------------| |
707 // | | SubDelReq 1 | |
708 // | |------------->| |
709 // | | | RouteUpdate |
710 // | | |-----> rtmgr |
712 // | | | RouteUpdate |
713 // | | | status:400 |
714 // | | |<----- rtmgr |
716 // | | SubDelResp 1 | |
717 // | |<-------------| |
720 // |--------------------------->| |
722 // | | | SubDelReq 2 |
723 // | | |------------->|
725 // | | | SubDelReq 2 |
726 // | | |------------->|
728 // | SubDelResp 2 | |
729 // |<---------------------------| |
731 //-----------------------------------------------------------------------------
732 func TestSubMergeDelAndRouteUpdateNok(t *testing.T) {
733 CaseBegin("TestSubMergeDelAndRouteUpdateNok")
735 // Init counter check
736 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
737 Counter{cSubReqFromXapp, 2},
738 Counter{cMergedSubscriptions, 1},
739 Counter{cSubReqToE2, 1},
740 Counter{cSubRespFromE2, 1},
741 Counter{cSubRespToXapp, 2},
742 Counter{cSubDelReqFromXapp, 2},
743 Counter{cRouteDeleteUpdateFail, 1},
744 Counter{cSubDelReqToE2, 1},
745 Counter{cSubDelRespFromE2, 1},
746 Counter{cSubDelRespToXapp, 2},
747 Counter{cUnmergedSubscriptions, 1},
751 rparams1 := &teststube2ap.E2StubSubsReqParams{}
753 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
754 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
755 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
756 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
759 rparams2 := &teststube2ap.E2StubSubsReqParams{}
761 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
762 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
764 resp, _ := xapp.Subscription.QuerySubscriptions()
765 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
766 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
767 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
770 waiter := rtmgrHttp.AllocNextEvent(false)
771 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
774 xappConn1.RecvSubsDelResp(t, deltrans1)
777 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
778 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
779 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
780 xappConn2.RecvSubsDelResp(t, deltrans2)
781 //Wait that subs is cleaned
782 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
784 xappConn1.TestMsgChanEmpty(t)
785 xappConn2.TestMsgChanEmpty(t)
786 e2termConn1.TestMsgChanEmpty(t)
787 mainCtrl.wait_registry_empty(t, 10)
789 mainCtrl.VerifyCounterValues(t)
792 //-----------------------------------------------------------------------------
794 //-----------------------------------------------------------------------------
795 // TestSubReqAndSubDelOk
798 // +-------+ +---------+ +---------+
799 // | xapp | | submgr | | e2term |
800 // +-------+ +---------+ +---------+
803 // |------------->| |
806 // | |------------->|
809 // | |<-------------|
812 // |<-------------| |
816 // |------------->| |
819 // | |------------->|
822 // | |<-------------|
825 // |<-------------| |
827 //-----------------------------------------------------------------------------
828 func TestSubReqAndSubDelOk(t *testing.T) {
829 CaseBegin("TestSubReqAndSubDelOk")
831 // Init counter check
832 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
833 Counter{cSubReqFromXapp, 1},
834 Counter{cSubReqToE2, 1},
835 Counter{cSubRespFromE2, 1},
836 Counter{cSubRespToXapp, 1},
837 Counter{cSubDelReqFromXapp, 1},
838 Counter{cSubDelReqToE2, 1},
839 Counter{cSubDelRespFromE2, 1},
840 Counter{cSubDelRespToXapp, 1},
843 cretrans := xappConn1.SendSubsReq(t, nil, nil)
844 crereq, cremsg := e2termConn1.RecvSubsReq(t)
845 e2termConn1.SendSubsResp(t, crereq, cremsg)
846 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
848 resp, _ := xapp.Subscription.QuerySubscriptions()
849 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
850 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
851 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
853 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
854 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
856 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
857 xappConn1.RecvSubsDelResp(t, deltrans)
859 //Wait that subs is cleaned
860 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
862 xappConn1.TestMsgChanEmpty(t)
863 xappConn2.TestMsgChanEmpty(t)
864 e2termConn1.TestMsgChanEmpty(t)
865 mainCtrl.wait_registry_empty(t, 10)
867 mainCtrl.VerifyCounterValues(t)
870 //-----------------------------------------------------------------------------
871 // TestSubReqRetransmission
874 // +-------+ +---------+ +---------+
875 // | xapp | | submgr | | e2term |
876 // +-------+ +---------+ +---------+
879 // |------------->| |
882 // | |------------->|
886 // |------------->| |
889 // | |<-------------|
892 // |<-------------| |
897 //-----------------------------------------------------------------------------
898 func TestSubReqRetransmission(t *testing.T) {
899 CaseBegin("TestSubReqRetransmission")
902 cretrans := xappConn1.SendSubsReq(t, nil, nil)
903 crereq, cremsg := e2termConn1.RecvSubsReq(t)
905 seqBef := mainCtrl.get_msgcounter(t)
906 xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq
907 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
909 // hack as there is no real way to see has message be handled.
910 // Previuos counter check just tells that is has been received by submgr
911 // --> artificial delay
912 <-time.After(1 * time.Second)
913 e2termConn1.SendSubsResp(t, crereq, cremsg)
914 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
917 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
918 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
919 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
920 xappConn1.RecvSubsDelResp(t, deltrans)
922 //Wait that subs is cleaned
923 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
925 xappConn1.TestMsgChanEmpty(t)
926 xappConn2.TestMsgChanEmpty(t)
927 e2termConn1.TestMsgChanEmpty(t)
928 mainCtrl.wait_registry_empty(t, 10)
931 //-----------------------------------------------------------------------------
932 // TestSubDelReqRetransmission
935 // +-------+ +---------+ +---------+
936 // | xapp | | submgr | | e2term |
937 // +-------+ +---------+ +---------+
943 // |------------->| |
946 // | |------------->|
951 // |------------->| |
954 // | |<-------------|
957 // |<-------------| |
959 //-----------------------------------------------------------------------------
960 func TestSubDelReqRetransmission(t *testing.T) {
961 CaseBegin("TestSubDelReqRetransmission")
964 cretrans := xappConn1.SendSubsReq(t, nil, nil)
965 crereq, cremsg := e2termConn1.RecvSubsReq(t)
966 e2termConn1.SendSubsResp(t, crereq, cremsg)
967 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
970 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
971 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
973 seqBef := mainCtrl.get_msgcounter(t)
974 xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq
975 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
977 // hack as there is no real way to see has message be handled.
978 // Previuos counter check just tells that is has been received by submgr
979 // --> artificial delay
980 <-time.After(1 * time.Second)
982 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
983 xappConn1.RecvSubsDelResp(t, deltrans)
985 //Wait that subs is cleaned
986 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
988 xappConn1.TestMsgChanEmpty(t)
989 xappConn2.TestMsgChanEmpty(t)
990 e2termConn1.TestMsgChanEmpty(t)
991 mainCtrl.wait_registry_empty(t, 10)
994 //-----------------------------------------------------------------------------
995 // TestSubDelReqCollision
998 // +-------+ +---------+ +---------+
999 // | xapp | | submgr | | e2term |
1000 // +-------+ +---------+ +---------+
1002 // | [SUBS CREATE] |
1005 // | SubDelReq 1 | |
1006 // |------------->| |
1008 // | | SubDelReq 1 |
1009 // | |------------->|
1011 // | SubDelReq 2 | |
1014 // |------------->| |
1016 // | | SubDelResp 1 |
1017 // | |<-------------|
1019 // | SubDelResp 1 | |
1020 // |<-------------| |
1022 // | SubDelResp 2 | |
1023 // |<-------------| |
1025 //-----------------------------------------------------------------------------
1027 func TestSubDelReqCollision(t *testing.T) {
1028 CaseBegin("TestSubDelReqCollision")
1031 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1032 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1033 e2termConn1.SendSubsResp(t, crereq, cremsg)
1034 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1037 xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1038 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1040 // Subs Delete colliding
1041 seqBef := mainCtrl.get_msgcounter(t)
1042 deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1043 xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq
1044 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
1046 // hack as there is no real way to see has message be handled.
1047 // Previuos counter check just tells that is has been received by submgr
1048 // --> artificial delay
1049 <-time.After(1 * time.Second)
1051 // Del resp for first and second
1052 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1054 // don't care in which order responses are received
1055 xappConn1.RecvSubsDelResp(t, nil)
1056 xappConn1.RecvSubsDelResp(t, nil)
1058 //Wait that subs is cleaned
1059 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1061 xappConn1.TestMsgChanEmpty(t)
1062 xappConn2.TestMsgChanEmpty(t)
1063 e2termConn1.TestMsgChanEmpty(t)
1064 mainCtrl.wait_registry_empty(t, 10)
1067 //-----------------------------------------------------------------------------
1068 // TestSubReqAndSubDelOkTwoParallel
1071 // +-------+ +-------+ +---------+ +---------+
1072 // | xapp | | xapp | | submgr | | e2term |
1073 // +-------+ +-------+ +---------+ +---------+
1078 // | |------------->| |
1081 // | | |------------->|
1084 // |------------------------>| |
1087 // | | |------------->|
1090 // | | |<-------------|
1092 // | |<-------------| |
1095 // | | |<-------------|
1097 // |<------------------------| |
1099 // | | [SUBS 1 DELETE] |
1101 // | | [SUBS 2 DELETE] |
1104 //-----------------------------------------------------------------------------
1106 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
1107 CaseBegin("TestSubReqAndSubDelOkTwoParallel")
1110 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1112 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1113 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1116 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1119 rparams2.Req.EventTriggerDefinition.Data.Length = 1
1120 rparams2.Req.EventTriggerDefinition.Data.Data = make([]uint8, rparams2.Req.EventTriggerDefinition.Data.Length)
1121 rparams2.Req.EventTriggerDefinition.Data.Data[0] = 2
1123 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1124 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1127 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1128 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1131 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1132 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1135 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1136 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1137 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1138 xappConn1.RecvSubsDelResp(t, deltrans1)
1139 //Wait that subs is cleaned
1140 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1143 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1144 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1145 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1146 xappConn2.RecvSubsDelResp(t, deltrans2)
1147 //Wait that subs is cleaned
1148 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1150 xappConn1.TestMsgChanEmpty(t)
1151 xappConn2.TestMsgChanEmpty(t)
1152 e2termConn1.TestMsgChanEmpty(t)
1153 mainCtrl.wait_registry_empty(t, 10)
1156 //-----------------------------------------------------------------------------
1157 // TestSameSubsDiffRan
1158 // Same subscription to different RANs
1161 // +-------+ +---------+ +---------+
1162 // | xapp | | submgr | | e2term |
1163 // +-------+ +---------+ +---------+
1168 // |------------->| |
1171 // | |------------->|
1173 // | | SubResp(r1) |
1174 // | |<-------------|
1176 // | SubResp(r1) | |
1177 // |<-------------| |
1180 // |------------->| |
1183 // | |------------->|
1185 // | | SubResp(r2) |
1186 // | |<-------------|
1188 // | SubResp(r2) | |
1189 // |<-------------| |
1191 // | [SUBS r1 DELETE] |
1193 // | [SUBS r2 DELETE] |
1196 //-----------------------------------------------------------------------------
1197 func TestSameSubsDiffRan(t *testing.T) {
1198 CaseBegin("TestSameSubsDiffRan")
1201 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1202 xappConn1.SendSubsReq(t, nil, cretrans1)
1203 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1204 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1205 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1208 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
1209 xappConn1.SendSubsReq(t, nil, cretrans2)
1210 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1211 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1212 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1215 deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1216 xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
1217 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1218 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1219 xappConn1.RecvSubsDelResp(t, deltrans1)
1220 //Wait that subs is cleaned
1221 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1224 deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
1225 xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
1226 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1227 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1228 xappConn1.RecvSubsDelResp(t, deltrans2)
1229 //Wait that subs is cleaned
1230 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1232 xappConn1.TestMsgChanEmpty(t)
1233 xappConn2.TestMsgChanEmpty(t)
1234 e2termConn1.TestMsgChanEmpty(t)
1235 mainCtrl.wait_registry_empty(t, 10)
1238 //-----------------------------------------------------------------------------
1239 // TestSubReqRetryInSubmgr
1242 // +-------+ +---------+ +---------+
1243 // | xapp | | submgr | | e2term |
1244 // +-------+ +---------+ +---------+
1247 // |------------->| |
1250 // | |------------->|
1254 // | |------------->|
1257 // | |<-------------|
1260 // |<-------------| |
1262 // | [SUBS DELETE] |
1265 //-----------------------------------------------------------------------------
1267 func TestSubReqRetryInSubmgr(t *testing.T) {
1268 CaseBegin("TestSubReqRetryInSubmgr start")
1270 // Init counter check
1271 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1272 Counter{cSubReqFromXapp, 1},
1273 Counter{cSubReqToE2, 1},
1274 Counter{cSubReqTimerExpiry, 1},
1275 Counter{cSubReReqToE2, 1},
1276 Counter{cSubRespFromE2, 1},
1277 Counter{cSubRespToXapp, 1},
1278 Counter{cSubDelReqFromXapp, 1},
1279 Counter{cSubDelReqToE2, 1},
1280 Counter{cSubDelRespFromE2, 1},
1281 Counter{cSubDelRespToXapp, 1},
1284 // Xapp: Send SubsReq
1285 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1287 // E2t: Receive 1st SubsReq
1288 e2termConn1.RecvSubsReq(t)
1290 // E2t: Receive 2nd SubsReq and send SubsResp
1291 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1292 e2termConn1.SendSubsResp(t, crereq, cremsg)
1294 // Xapp: Receive SubsResp
1295 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1297 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1298 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1299 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1300 xappConn1.RecvSubsDelResp(t, deltrans)
1302 // Wait that subs is cleaned
1303 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1305 xappConn1.TestMsgChanEmpty(t)
1306 xappConn2.TestMsgChanEmpty(t)
1307 e2termConn1.TestMsgChanEmpty(t)
1308 mainCtrl.wait_registry_empty(t, 10)
1310 mainCtrl.VerifyCounterValues(t)
1313 //-----------------------------------------------------------------------------
1314 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
1317 // +-------+ +---------+ +---------+
1318 // | xapp | | submgr | | e2term |
1319 // +-------+ +---------+ +---------+
1322 // |------------->| |
1325 // | |------------->|
1329 // | |------------->|
1332 // | |------------->|
1335 // | |<-------------|
1338 //-----------------------------------------------------------------------------
1339 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
1340 CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
1342 // Init counter check
1343 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1344 Counter{cSubReqFromXapp, 1},
1345 Counter{cSubReqToE2, 1},
1346 Counter{cSubReReqToE2, 1},
1347 Counter{cSubReqTimerExpiry, 2},
1348 Counter{cSubDelReqToE2, 1},
1349 Counter{cSubDelRespFromE2, 1},
1352 // Xapp: Send SubsReq
1353 xappConn1.SendSubsReq(t, nil, nil)
1355 // E2t: Receive 1st SubsReq
1356 e2termConn1.RecvSubsReq(t)
1358 // E2t: Receive 2nd SubsReq
1359 e2termConn1.RecvSubsReq(t)
1361 // E2t: Send receive SubsDelReq and send SubsResp
1362 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1363 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1365 // Wait that subs is cleaned
1366 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 10)
1368 xappConn1.TestMsgChanEmpty(t)
1369 xappConn2.TestMsgChanEmpty(t)
1370 e2termConn1.TestMsgChanEmpty(t)
1371 mainCtrl.wait_registry_empty(t, 10)
1373 mainCtrl.VerifyCounterValues(t)
1376 //-----------------------------------------------------------------------------
1377 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
1380 // +-------+ +---------+ +---------+
1381 // | xapp | | submgr | | e2term |
1382 // +-------+ +---------+ +---------+
1385 // |------------->| |
1388 // | |------------->|
1392 // | |------------->|
1395 // | |------------->|
1399 // | |------------->|
1403 //-----------------------------------------------------------------------------
1405 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
1406 CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
1408 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1409 Counter{cSubReqFromXapp, 1},
1410 Counter{cSubReqToE2, 1},
1411 Counter{cSubReReqToE2, 1},
1412 Counter{cSubReqTimerExpiry, 2},
1413 Counter{cSubDelReqToE2, 1},
1414 Counter{cSubDelReReqToE2, 1},
1415 Counter{cSubDelReqTimerExpiry, 2},
1418 // Xapp: Send SubsReq
1419 xappConn1.SendSubsReq(t, nil, nil)
1421 // E2t: Receive 1st SubsReq
1422 e2termConn1.RecvSubsReq(t)
1424 // E2t: Receive 2nd SubsReq
1425 e2termConn1.RecvSubsReq(t)
1427 // E2t: Receive 1st SubsDelReq
1428 e2termConn1.RecvSubsDelReq(t)
1430 // E2t: Receive 2nd SubsDelReq
1431 delreq, _ := e2termConn1.RecvSubsDelReq(t)
1433 // Wait that subs is cleaned
1434 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 15)
1436 xappConn1.TestMsgChanEmpty(t)
1437 xappConn2.TestMsgChanEmpty(t)
1438 e2termConn1.TestMsgChanEmpty(t)
1439 mainCtrl.wait_registry_empty(t, 10)
1441 mainCtrl.VerifyCounterValues(t)
1444 //-----------------------------------------------------------------------------
1445 // TestSubReqSubFailRespInSubmgr
1448 // +-------+ +---------+ +---------+
1449 // | xapp | | submgr | | e2term |
1450 // +-------+ +---------+ +---------+
1453 // |------------->| |
1456 // | |------------->|
1459 // | |<-------------|
1462 // |<-------------| |
1465 //-----------------------------------------------------------------------------
1467 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1468 CaseBegin("TestSubReqSubFailRespInSubmgr start")
1470 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1471 Counter{cSubReqFromXapp, 1},
1472 Counter{cSubReqToE2, 1},
1473 Counter{cSubFailFromE2, 1},
1474 Counter{cSubFailToXapp, 1},
1477 // Xapp: Send SubsReq
1478 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1480 // E2t: Receive SubsReq and send SubsFail (first)
1481 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1482 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1483 fparams1.Set(crereq1)
1484 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1486 // Xapp: Receive SubsFail
1487 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
1489 // Wait that subs is cleaned
1490 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1492 xappConn1.TestMsgChanEmpty(t)
1493 xappConn2.TestMsgChanEmpty(t)
1494 e2termConn1.TestMsgChanEmpty(t)
1495 mainCtrl.wait_registry_empty(t, 10)
1497 mainCtrl.VerifyCounterValues(t)
1500 //-----------------------------------------------------------------------------
1501 // TestSubDelReqRetryInSubmgr
1504 // +-------+ +---------+ +---------+
1505 // | xapp | | submgr | | e2term |
1506 // +-------+ +---------+ +---------+
1508 // | [SUBS CREATE] |
1512 // |------------->| |
1515 // | |------------->|
1518 // | |------------->|
1521 // | |<-------------|
1524 // |<-------------| |
1526 //-----------------------------------------------------------------------------
1528 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1530 CaseBegin("TestSubDelReqRetryInSubmgr start")
1533 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1534 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1535 e2termConn1.SendSubsResp(t, crereq, cremsg)
1536 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1539 // Xapp: Send SubsDelReq
1540 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1542 // E2t: Receive 1st SubsDelReq
1543 e2termConn1.RecvSubsDelReq(t)
1545 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1546 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1547 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1549 // Xapp: Receive SubsDelResp
1550 xappConn1.RecvSubsDelResp(t, deltrans)
1552 // Wait that subs is cleaned
1553 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1555 xappConn1.TestMsgChanEmpty(t)
1556 xappConn2.TestMsgChanEmpty(t)
1557 e2termConn1.TestMsgChanEmpty(t)
1558 mainCtrl.wait_registry_empty(t, 10)
1561 //-----------------------------------------------------------------------------
1562 // TestSubDelReqTwoRetriesNoRespInSubmgr
1565 // +-------+ +---------+ +---------+
1566 // | xapp | | submgr | | e2term |
1567 // +-------+ +---------+ +---------+
1569 // | [SUBS CREATE] |
1573 // |------------->| |
1576 // | |------------->|
1579 // | |------------->|
1583 // |<-------------| |
1585 //-----------------------------------------------------------------------------
1587 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1589 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
1592 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1593 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1594 e2termConn1.SendSubsResp(t, crereq, cremsg)
1595 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1598 // Xapp: Send SubsDelReq
1599 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1601 // E2t: Receive 1st SubsDelReq
1602 e2termConn1.RecvSubsDelReq(t)
1604 // E2t: Receive 2nd SubsDelReq
1605 e2termConn1.RecvSubsDelReq(t)
1607 // Xapp: Receive SubsDelResp
1608 xappConn1.RecvSubsDelResp(t, deltrans)
1610 // Wait that subs is cleaned
1611 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1613 xappConn1.TestMsgChanEmpty(t)
1614 xappConn2.TestMsgChanEmpty(t)
1615 e2termConn1.TestMsgChanEmpty(t)
1616 mainCtrl.wait_registry_empty(t, 10)
1619 //-----------------------------------------------------------------------------
1620 // TestSubDelReqSubDelFailRespInSubmgr
1623 // +-------+ +---------+ +---------+
1624 // | xapp | | submgr | | e2term |
1625 // +-------+ +---------+ +---------+
1627 // | [SUBS CREATE] |
1631 // |------------->| |
1634 // | |------------->|
1637 // | |<-------------|
1640 // |<-------------| |
1643 //-----------------------------------------------------------------------------
1645 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1646 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1648 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1649 Counter{cSubReqFromXapp, 1},
1650 Counter{cSubReqToE2, 1},
1651 Counter{cSubRespFromE2, 1},
1652 Counter{cSubRespToXapp, 1},
1653 Counter{cSubDelReqFromXapp, 1},
1654 Counter{cSubDelReqToE2, 1},
1655 Counter{cSubDelFailFromE2, 1},
1656 Counter{cSubDelRespToXapp, 1},
1660 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1661 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1662 e2termConn1.SendSubsResp(t, crereq, cremsg)
1663 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1665 // Xapp: Send SubsDelReq
1666 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1668 // E2t: Send receive SubsDelReq and send SubsDelFail
1669 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1670 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1672 // Xapp: Receive SubsDelResp
1673 xappConn1.RecvSubsDelResp(t, deltrans)
1675 // Wait that subs is cleaned
1676 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1678 xappConn1.TestMsgChanEmpty(t)
1679 xappConn2.TestMsgChanEmpty(t)
1680 e2termConn1.TestMsgChanEmpty(t)
1681 mainCtrl.wait_registry_empty(t, 10)
1683 mainCtrl.VerifyCounterValues(t)
1686 //-----------------------------------------------------------------------------
1687 // TestSubReqAndSubDelOkSameAction
1690 // +-------+ +-------+ +---------+ +---------+
1691 // | xapp2 | | xapp1 | | submgr | | e2term |
1692 // +-------+ +-------+ +---------+ +---------+
1697 // | |------------->| |
1700 // | | |------------->|
1702 // | | |<-------------|
1704 // | |<-------------| |
1707 // |--------------------------->| |
1710 // |<---------------------------| |
1712 // | | SubDelReq 1 | |
1713 // | |------------->| |
1715 // | | SubDelResp 1 | |
1716 // | |<-------------| |
1718 // | SubDelReq 2 | |
1719 // |--------------------------->| |
1721 // | | | SubDelReq 2 |
1722 // | | |------------->|
1724 // | | | SubDelReq 2 |
1725 // | | |------------->|
1727 // | SubDelResp 2 | |
1728 // |<---------------------------| |
1730 //-----------------------------------------------------------------------------
1731 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
1732 CaseBegin("TestSubReqAndSubDelOkSameAction")
1734 // Init counter check
1735 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1736 Counter{cSubReqFromXapp, 2},
1737 Counter{cSubReqToE2, 1},
1738 Counter{cSubRespFromE2, 1},
1739 Counter{cSubRespToXapp, 2},
1740 Counter{cMergedSubscriptions, 1},
1741 Counter{cUnmergedSubscriptions, 1},
1742 Counter{cSubDelReqFromXapp, 2},
1743 Counter{cSubDelReqToE2, 1},
1744 Counter{cSubDelRespFromE2, 1},
1745 Counter{cSubDelRespToXapp, 2},
1749 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1751 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1752 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1753 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1754 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1757 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1759 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1760 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1762 resp, _ := xapp.Subscription.QuerySubscriptions()
1763 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1764 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1765 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
1768 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1769 xappConn1.RecvSubsDelResp(t, deltrans1)
1772 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1773 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1774 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1775 xappConn2.RecvSubsDelResp(t, deltrans2)
1776 //Wait that subs is cleaned
1777 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1779 xappConn1.TestMsgChanEmpty(t)
1780 xappConn2.TestMsgChanEmpty(t)
1781 e2termConn1.TestMsgChanEmpty(t)
1782 mainCtrl.wait_registry_empty(t, 10)
1784 mainCtrl.VerifyCounterValues(t)
1787 //-----------------------------------------------------------------------------
1788 // TestSubReqAndSubDelOkSameActionParallel
1791 // +-------+ +-------+ +---------+ +---------+
1792 // | xapp2 | | xapp1 | | submgr | | e2term |
1793 // +-------+ +-------+ +---------+ +---------+
1798 // | |------------->| |
1801 // | | |------------->|
1803 // |--------------------------->| |
1805 // | | |<-------------|
1807 // | |<-------------| |
1810 // |<---------------------------| |
1812 // | | SubDelReq 1 | |
1813 // | |------------->| |
1815 // | | SubDelResp 1 | |
1816 // | |<-------------| |
1818 // | SubDelReq 2 | |
1819 // |--------------------------->| |
1821 // | | | SubDelReq 2 |
1822 // | | |------------->|
1824 // | | | SubDelReq 2 |
1825 // | | |------------->|
1827 // | SubDelResp 2 | |
1828 // |<---------------------------| |
1830 //-----------------------------------------------------------------------------
1831 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1832 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1835 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1837 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1838 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1841 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1843 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1846 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1847 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1850 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1853 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1854 xappConn1.RecvSubsDelResp(t, deltrans1)
1857 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1858 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1859 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1860 xappConn2.RecvSubsDelResp(t, deltrans2)
1862 //Wait that subs is cleaned
1863 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1865 xappConn1.TestMsgChanEmpty(t)
1866 xappConn2.TestMsgChanEmpty(t)
1867 e2termConn1.TestMsgChanEmpty(t)
1868 mainCtrl.wait_registry_empty(t, 10)
1871 //-----------------------------------------------------------------------------
1872 // TestSubReqAndSubDelNokSameActionParallel
1875 // +-------+ +-------+ +---------+ +---------+
1876 // | xapp2 | | xapp1 | | submgr | | e2term |
1877 // +-------+ +-------+ +---------+ +---------+
1882 // | |------------->| |
1885 // | | |------------->|
1887 // |--------------------------->| |
1889 // | | |<-------------|
1892 // | |<-------------| |
1895 // |<---------------------------| |
1897 //-----------------------------------------------------------------------------
1898 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1899 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1902 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1904 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1906 // E2t: Receive SubsReq (first)
1907 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1910 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1912 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1913 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1914 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1916 // E2t: send SubsFail (first)
1917 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1918 fparams1.Set(crereq1)
1919 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1922 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1924 xappConn2.RecvSubsFail(t, cretrans2)
1926 //Wait that subs is cleaned
1927 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1929 xappConn1.TestMsgChanEmpty(t)
1930 xappConn2.TestMsgChanEmpty(t)
1931 e2termConn1.TestMsgChanEmpty(t)
1932 mainCtrl.wait_registry_empty(t, 10)
1935 //-----------------------------------------------------------------------------
1936 // TestSubReqAndSubDelNoAnswerSameActionParallel
1939 // +-------+ +-------+ +---------+ +---------+
1940 // | xapp2 | | xapp1 | | submgr | | e2term |
1941 // +-------+ +-------+ +---------+ +---------+
1946 // | |------------->| |
1949 // | | |------------->|
1951 // |--------------------------->| |
1954 // | | |------------->|
1957 // | | | SubDelReq |
1958 // | | |------------->|
1960 // | | | SubDelResp |
1961 // | | |<-------------|
1963 //-----------------------------------------------------------------------------
1964 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1965 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1968 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1970 xappConn1.SendSubsReq(t, rparams1, nil)
1972 crereq1, _ := e2termConn1.RecvSubsReq(t)
1975 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1977 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1978 xappConn2.SendSubsReq(t, rparams2, nil)
1979 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1981 //Req1 (retransmitted)
1982 e2termConn1.RecvSubsReq(t)
1984 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1985 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1987 //Wait that subs is cleaned
1988 mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10)
1990 xappConn1.TestMsgChanEmpty(t)
1991 xappConn2.TestMsgChanEmpty(t)
1992 e2termConn1.TestMsgChanEmpty(t)
1993 mainCtrl.wait_registry_empty(t, 15)
1996 //----------------------------- Policy cases ---------------------------------
1997 //-----------------------------------------------------------------------------
1998 // TestSubReqPolicyAndSubDelOk
2001 // +-------+ +---------+ +---------+
2002 // | xapp | | submgr | | e2term |
2003 // +-------+ +---------+ +---------+
2006 // |------------->| |
2009 // | |------------->|
2012 // | |<-------------|
2015 // |<-------------| |
2019 // |------------->| |
2022 // | |------------->|
2025 // | |<-------------|
2028 // |<-------------| |
2030 //-----------------------------------------------------------------------------
2031 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
2032 CaseBegin("TestSubReqAndSubDelOk")
2034 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2036 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
2037 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2039 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2040 e2termConn1.SendSubsResp(t, crereq, cremsg)
2041 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2042 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2043 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2045 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2046 xappConn1.RecvSubsDelResp(t, deltrans)
2048 //Wait that subs is cleaned
2049 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2051 xappConn1.TestMsgChanEmpty(t)
2052 xappConn2.TestMsgChanEmpty(t)
2053 e2termConn1.TestMsgChanEmpty(t)
2054 mainCtrl.wait_registry_empty(t, 10)
2057 //-----------------------------------------------------------------------------
2058 // TestSubReqPolicyChangeAndSubDelOk
2061 // +-------+ +---------+ +---------+
2062 // | xapp | | submgr | | e2term |
2063 // +-------+ +---------+ +---------+
2066 // |------------->| |
2069 // | |------------->|
2072 // | |<-------------|
2075 // |<-------------| |
2078 // |------------->| |
2081 // | |------------->|
2084 // | |<-------------|
2087 // |<-------------| |
2090 // |------------->| |
2093 // | |------------->|
2096 // | |<-------------|
2099 // |<-------------| |
2101 //-----------------------------------------------------------------------------
2103 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
2104 CaseBegin("TestSubReqAndSubDelOk")
2106 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2108 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
2109 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2111 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2112 e2termConn1.SendSubsResp(t, crereq, cremsg)
2113 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2116 rparams1.Req.RequestId.InstanceId = e2SubsId
2117 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
2118 xappConn1.SendSubsReq(t, rparams1, cretrans)
2120 crereq, cremsg = e2termConn1.RecvSubsReq(t)
2121 e2termConn1.SendSubsResp(t, crereq, cremsg)
2122 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2123 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2124 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2126 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2127 xappConn1.RecvSubsDelResp(t, deltrans)
2129 //Wait that subs is cleaned
2130 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2132 xappConn1.TestMsgChanEmpty(t)
2133 xappConn2.TestMsgChanEmpty(t)
2134 e2termConn1.TestMsgChanEmpty(t)
2135 mainCtrl.wait_registry_empty(t, 10)
2138 //-----------------------------------------------------------------------------
2139 // TestSubReqAndSubDelOkTwoE2termParallel
2142 // +-------+ +---------+ +---------+ +---------+
2143 // | xapp | | submgr | | e2term1 | | e2term2 |
2144 // +-------+ +---------+ +---------+ +---------+
2149 // |------------->| | |
2152 // | |------------->| |
2155 // |------------->| | |
2158 // | |---------------------------->|
2161 // | |<-------------| |
2163 // |<-------------| | |
2165 // | |<----------------------------|
2167 // |<-------------| | |
2169 // | [SUBS 1 DELETE] | |
2171 // | [SUBS 2 DELETE] | |
2174 //-----------------------------------------------------------------------------
2175 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
2176 CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
2179 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
2180 xappConn1.SendSubsReq(t, nil, cretrans1)
2181 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2183 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
2184 xappConn1.SendSubsReq(t, nil, cretrans2)
2185 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
2188 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2189 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2192 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
2193 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
2196 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2197 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2198 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2199 xappConn1.RecvSubsDelResp(t, deltrans1)
2200 //Wait that subs is cleaned
2201 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
2204 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
2205 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
2206 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
2207 xappConn1.RecvSubsDelResp(t, deltrans2)
2208 //Wait that subs is cleaned
2209 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2211 xappConn1.TestMsgChanEmpty(t)
2212 xappConn2.TestMsgChanEmpty(t)
2213 e2termConn1.TestMsgChanEmpty(t)
2214 e2termConn2.TestMsgChanEmpty(t)
2215 mainCtrl.wait_registry_empty(t, 10)
2218 //-----------------------------------------------------------------------------
2219 // TestSubReqInsertAndSubDelOk
2222 // +-------+ +---------+ +---------+
2223 // | xapp | | submgr | | e2term |
2224 // +-------+ +---------+ +---------+
2227 // |------------->| |
2230 // | |------------->|
2233 // | |<-------------|
2236 // |<-------------| |
2240 // |------------->| |
2243 // | |------------->|
2246 // | |<-------------|
2249 // |<-------------| |
2251 //-----------------------------------------------------------------------------
2252 func TestSubReqInsertAndSubDelOk(t *testing.T) {
2253 CaseBegin("TestInsertSubReqAndSubDelOk")
2255 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2257 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeInsert
2258 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2260 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2261 e2termConn1.SendSubsResp(t, crereq, cremsg)
2262 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2263 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2264 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2266 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2267 xappConn1.RecvSubsDelResp(t, deltrans)
2269 //Wait that subs is cleaned
2270 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2272 xappConn1.TestMsgChanEmpty(t)
2273 xappConn2.TestMsgChanEmpty(t)
2274 e2termConn1.TestMsgChanEmpty(t)
2275 mainCtrl.wait_registry_empty(t, 10)
2278 //-----------------------------------------------------------------------------
2279 // TestSubReqRetransmissionWithSameSubIdDiffXid
2281 // This case simulates case where xApp restarts and starts sending same
2282 // subscription requests which have already subscribed successfully
2285 // +-------+ +---------+ +---------+
2286 // | xapp | | submgr | | e2term |
2287 // +-------+ +---------+ +---------+
2290 // |------------->| |
2293 // | |------------->|
2296 // | |<-------------|
2299 // |<-------------| |
2301 // | xApp restart | |
2304 // | (retrans with same xApp generated subid but diff xid)
2305 // |------------->| |
2308 // |<-------------| |
2310 // | [SUBS DELETE] |
2313 //-----------------------------------------------------------------------------
2314 func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) {
2315 CaseBegin("TestSubReqRetransmissionWithSameSubIdDiffXid")
2318 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2319 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2320 e2termConn1.SendSubsResp(t, crereq, cremsg)
2321 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2323 // xApp restart here
2324 // --> artificial delay
2325 <-time.After(1 * time.Second)
2328 cretrans = xappConn1.SendSubsReq(t, nil, nil) //Retransmitted SubReq
2329 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2332 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2333 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2334 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2335 xappConn1.RecvSubsDelResp(t, deltrans)
2337 //Wait that subs is cleaned
2338 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2340 xappConn1.TestMsgChanEmpty(t)
2341 xappConn2.TestMsgChanEmpty(t)
2342 e2termConn1.TestMsgChanEmpty(t)
2343 mainCtrl.wait_registry_empty(t, 10)
2346 //-----------------------------------------------------------------------------
2347 // TestSubReqNokAndSubDelOkWithRestartInMiddle
2350 // +-------+ +---------+ +---------+
2351 // | xapp | | submgr | | e2term |
2352 // +-------+ +---------+ +---------+
2355 // |------------->| |
2358 // | |------------->|
2363 // | Submgr restart |
2367 // | |------------->|
2370 // | |<-------------|
2373 //-----------------------------------------------------------------------------
2375 func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
2376 CaseBegin("TestSubReqNokAndSubDelOkWithRestartInMiddle")
2378 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
2379 xappConn1.SendSubsReq(t, nil, nil)
2380 e2termConn1.RecvSubsReq(t)
2381 mainCtrl.SetResetTestFlag(t, false)
2383 resp, _ := xapp.Subscription.QuerySubscriptions()
2384 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2385 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2386 e2SubsId := uint32(resp[0].SubscriptionID)
2387 t.Logf("e2SubsId = %v", e2SubsId)
2389 mainCtrl.SimulateRestart(t)
2390 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2392 // Submgr send delete for uncompleted subscription
2393 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2394 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2396 // Wait that subs is cleaned
2397 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2399 xappConn1.TestMsgChanEmpty(t)
2400 xappConn2.TestMsgChanEmpty(t)
2401 e2termConn1.TestMsgChanEmpty(t)
2402 mainCtrl.wait_registry_empty(t, 10)
2405 //-----------------------------------------------------------------------------
2406 // TestSubReqAndSubDelOkWithRestartInMiddle
2409 // +-------+ +---------+ +---------+
2410 // | xapp | | submgr | | e2term |
2411 // +-------+ +---------+ +---------+
2414 // |------------->| |
2417 // | |------------->|
2420 // | |<-------------|
2423 // |<-------------| |
2426 // | Submgr restart |
2429 // |------------->| |
2432 // | |------------->|
2435 // | |<-------------|
2438 // |<-------------| |
2440 //-----------------------------------------------------------------------------
2442 func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
2443 CaseBegin("TestSubReqAndSubDelOkWithRestartInMiddle")
2445 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2446 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2447 e2termConn1.SendSubsResp(t, crereq, cremsg)
2448 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2450 // Check subscription
2451 resp, _ := xapp.Subscription.QuerySubscriptions()
2452 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2453 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2454 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2456 mainCtrl.SimulateRestart(t)
2457 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2459 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
2460 // That needs to be completed before successful subscription query is possible
2461 <-time.After(time.Second * 1)
2463 // Check that subscription is restored correctly after restart
2464 resp, _ = xapp.Subscription.QuerySubscriptions()
2465 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2466 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2467 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2469 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2470 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2471 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2472 xappConn1.RecvSubsDelResp(t, deltrans)
2474 //Wait that subs is cleaned
2475 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2477 xappConn1.TestMsgChanEmpty(t)
2478 xappConn2.TestMsgChanEmpty(t)
2479 e2termConn1.TestMsgChanEmpty(t)
2480 mainCtrl.wait_registry_empty(t, 10)
2483 //-----------------------------------------------------------------------------
2484 // TestSubReqAndSubDelOkSameActionWithRestartsInMiddle
2487 // +-------+ +-------+ +---------+ +---------+
2488 // | xapp2 | | xapp1 | | submgr | | e2term |
2489 // +-------+ +-------+ +---------+ +---------+
2494 // | |------------->| |
2497 // | | |------------->|
2499 // | | |<-------------|
2501 // | |<-------------| |
2504 // | submgr restart |
2509 // |--------------------------->| |
2512 // |<---------------------------| |
2514 // | | SubDelReq 1 | |
2515 // | |------------->| |
2517 // | | SubDelResp 1 | |
2518 // | |<-------------| |
2522 // | submgr restart |
2525 // | SubDelReq 2 | |
2526 // |--------------------------->| |
2528 // | | | SubDelReq 2 |
2529 // | | |------------->|
2531 // | | | SubDelReq 2 |
2532 // | | |------------->|
2534 // | SubDelResp 2 | |
2535 // |<---------------------------| |
2537 //-----------------------------------------------------------------------------
2539 func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
2540 CaseBegin("TestSubReqAndSubDelOkSameActionWithRestartsInMiddle")
2543 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2545 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2546 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2547 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2548 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2551 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2553 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2554 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
2556 // Check subscription
2557 resp, _ := xapp.Subscription.QuerySubscriptions()
2558 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2559 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2560 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2562 mainCtrl.SimulateRestart(t)
2563 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2565 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
2566 // That needs to be completed before successful subscription query is possible
2567 <-time.After(time.Second * 1)
2569 // Check that subscription is restored correctly after restart
2570 resp, _ = xapp.Subscription.QuerySubscriptions()
2571 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2572 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2573 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2576 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2577 xapp.Logger.Debug("xappConn1.RecvSubsDelResp")
2578 xappConn1.RecvSubsDelResp(t, deltrans1)
2579 xapp.Logger.Debug("xappConn1.RecvSubsDelResp received")
2581 mainCtrl.SimulateRestart(t)
2582 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2584 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
2585 // Submgr need be ready before successful subscription deletion is possible
2586 <-time.After(time.Second * 1)
2589 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
2590 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2592 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2593 xappConn2.RecvSubsDelResp(t, deltrans2)
2595 //Wait that subs is cleaned
2596 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2598 xappConn1.TestMsgChanEmpty(t)
2599 xappConn2.TestMsgChanEmpty(t)
2600 e2termConn1.TestMsgChanEmpty(t)
2601 mainCtrl.wait_registry_empty(t, 10)
2604 //*****************************************************************************
2605 // REST interface test cases
2606 //*****************************************************************************
2608 //-----------------------------------------------------------------------------
2609 // Test debug GET and POST requests
2612 // +-------+ +---------+
2613 // | user | | submgr |
2614 // +-------+ +---------+
2621 func TestGetSubscriptions(t *testing.T) {
2623 mainCtrl.sendGetRequest(t, "localhost:8088", "/ric/v1/subscriptions")
2626 func TestGetSymptomData(t *testing.T) {
2628 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/symptomdata")
2631 func TestPostdeleteSubId(t *testing.T) {
2633 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/deletesubid=1")
2636 func TestPostEmptyDb(t *testing.T) {
2638 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/emptydb")
2641 func TestGetRestSubscriptions(t *testing.T) {
2643 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/restsubscriptions")
2646 //-----------------------------------------------------------------------------
2647 // TestRESTSubReqAndRouteNok
2650 // +-------+ +---------+ +---------+
2651 // | xapp | | submgr | | rtmgr |
2652 // +-------+ +---------+ +---------+
2655 // |---------------->| |
2657 // | RESTSubResp | |
2658 // |<----------------| |
2659 // | | RouteCreate |
2660 // | |------------->|
2662 // | | RouteCreate |
2664 // | |(Bad request) |
2665 // | |<-------------|
2667 // |<----------------| |
2669 // | [SUBS INT DELETE] |
2671 // | RESTSubDelReq | |
2672 // |---------------->| |
2673 // | RESTSubDelResp | |
2674 // |<----------------| |
2676 //-----------------------------------------------------------------------------
2677 func TestRESTSubReqAndRouteNok(t *testing.T) {
2678 CaseBegin("TestRESTSubReqAndRouteNok")
2680 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2681 Counter{cRestSubReqFromXapp, 1},
2682 Counter{cRestSubRespToXapp, 1},
2683 Counter{cRouteCreateFail, 1},
2684 Counter{cRestSubFailNotifToXapp, 1},
2685 Counter{cRestSubDelReqFromXapp, 1},
2686 Counter{cRestSubDelRespToXapp, 1},
2689 const subReqCount int = 1
2691 // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
2692 waiter := rtmgrHttp.AllocNextSleep(50, false)
2693 newSubsId := mainCtrl.get_registry_next_subid(t)
2696 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2697 restSubId := xappConn1.SendRESTSubsReq(t, params)
2698 xappConn1.ExpectRESTNotificationNok(t, restSubId, "failAll")
2699 waiter.WaitResult(t)
2701 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2702 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
2705 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2707 // Wait that subs is cleaned
2708 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2709 waitSubsCleanup(t, e2SubsId, 10)
2710 mainCtrl.VerifyCounterValues(t)
2711 mainCtrl.VerifyAllClean(t)
2714 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
2715 CaseBegin("TestSubReqAndRouteUpdateNok")
2717 //Init counter check
2718 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2719 Counter{cRestSubReqFromXapp, 2},
2720 Counter{cRestSubRespToXapp, 2},
2721 Counter{cSubReqToE2, 1},
2722 Counter{cSubRespFromE2, 1},
2723 Counter{cRestSubNotifToXapp, 1},
2724 Counter{cRestSubFailNotifToXapp, 1},
2725 Counter{cRouteCreateUpdateFail, 1},
2726 Counter{cRestSubDelReqFromXapp, 2},
2727 Counter{cSubDelReqToE2, 1},
2728 Counter{cSubDelRespFromE2, 1},
2729 Counter{cRestSubDelRespToXapp, 2},
2732 var params *teststube2ap.RESTSubsReqParams = nil
2735 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2737 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2739 // xapp2 ROUTE creation shall fail with 400 from rtmgr -> submgr
2740 waiter := rtmgrHttp.AllocNextEvent(false)
2741 newSubsId := mainCtrl.get_registry_next_subid(t)
2742 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
2743 params.SetMeid("RAN_NAME_1")
2744 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2745 xapp.Logger.Debug("Send REST subscriber request for second subscriber : %v", restSubId2)
2746 xappConn2.ExpectRESTNotificationNok(t, restSubId2, "allFail")
2747 waiter.WaitResult(t)
2748 xappConn2.WaitRESTNotification(t, restSubId2)
2750 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2752 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2753 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
2755 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2756 //Wait that subs is cleaned
2757 waitSubsCleanup(t, e2SubsId, 10)
2759 mainCtrl.VerifyCounterValues(t)
2760 mainCtrl.VerifyAllClean(t)
2763 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
2764 CaseBegin("TestRESTSubDelReqAndRouteDeleteNok")
2766 // Init counter check
2767 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2768 Counter{cRestSubReqFromXapp, 1},
2769 Counter{cRestSubRespToXapp, 1},
2770 Counter{cSubReqToE2, 1},
2771 Counter{cSubRespFromE2, 1},
2772 Counter{cRestSubNotifToXapp, 1},
2773 Counter{cRestSubDelReqFromXapp, 1},
2774 Counter{cRouteDeleteFail, 1},
2775 Counter{cSubDelReqToE2, 1},
2776 Counter{cSubDelRespFromE2, 1},
2777 Counter{cRestSubDelRespToXapp, 1},
2780 var params *teststube2ap.RESTSubsReqParams = nil
2783 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2785 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2787 waiter := rtmgrHttp.AllocNextEvent(false)
2788 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2789 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2790 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2791 waiter.WaitResult(t)
2793 waitSubsCleanup(t, e2SubsId, 10)
2794 mainCtrl.VerifyCounterValues(t)
2795 mainCtrl.VerifyAllClean(t)
2798 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
2799 CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok")
2801 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2802 Counter{cRestSubReqFromXapp, 2},
2803 Counter{cMergedSubscriptions, 1},
2804 Counter{cRestSubRespToXapp, 2},
2805 Counter{cSubReqToE2, 1},
2806 Counter{cSubRespFromE2, 1},
2807 Counter{cRestSubNotifToXapp, 2},
2808 Counter{cRestSubDelReqFromXapp, 2},
2809 Counter{cRouteDeleteUpdateFail, 1},
2810 Counter{cSubDelReqToE2, 1},
2811 Counter{cSubDelRespFromE2, 1},
2812 Counter{cRestSubDelRespToXapp, 2},
2813 Counter{cUnmergedSubscriptions, 1},
2816 var params *teststube2ap.RESTSubsReqParams = nil
2819 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2821 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2822 restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1")
2824 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
2826 //Del1, this shall fail on rtmgr side
2827 waiter := rtmgrHttp.AllocNextEvent(false)
2828 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2829 waiter.WaitResult(t)
2831 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"})
2834 deleteXapp2Subscription(t, &restSubId2)
2836 waitSubsCleanup(t, e2SubsId2, 10)
2837 mainCtrl.VerifyCounterValues(t)
2838 mainCtrl.VerifyAllClean(t)
2841 //-----------------------------------------------------------------------------
2842 // TestRESTSubReqRetransmission
2845 // +-------+ +---------+ +---------+
2846 // | xapp | | submgr | | e2term |
2847 // +-------+ +---------+ +---------+
2849 // | RESTSubReq1 | |
2850 // |---------------->| |
2852 // | RESTSubResp | |
2853 // |<----------------| |
2855 // | |------------->|
2857 // | RESTSubReq2 | |
2859 // |---------------->| |
2860 // | RESTSubResp(201)| |
2861 // |<----------------| |
2864 // | |<-------------|
2866 // |<----------------| |
2868 // | [SUBS DELETE] |
2871 //-----------------------------------------------------------------------------
2873 func TestRESTSubReqRetransmission(t *testing.T) {
2874 CaseBegin("TestRESTSubReqRetransmission")
2876 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2877 Counter{cRestSubReqFromXapp, 2},
2878 Counter{cRestSubRespToXapp, 2},
2879 Counter{cSubReqToE2, 1},
2880 Counter{cSubRespFromE2, 1},
2881 Counter{cRestSubNotifToXapp, 1},
2882 Counter{cRestSubDelReqFromXapp, 1},
2883 Counter{cSubDelReqToE2, 1},
2884 Counter{cSubDelRespFromE2, 1},
2885 Counter{cRestSubDelRespToXapp, 1},
2887 // Retry/duplicate will get the same way as the first request.
2888 // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
2889 // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
2892 const subReqCount int = 1
2894 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2895 restSubId := xappConn1.SendRESTSubsReq(t, params)
2897 xappConn1.SendRESTSubsReq(t, params)
2898 <-time.After(time.Second * 1)
2900 xappConn1.WaitListedRestNotifications(t, []string{restSubId})
2902 // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
2903 // the order is not significant here.
2904 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2905 e2termConn1.SendSubsResp(t, crereq, cremsg)
2907 e2SubsId := <-xappConn1.ListedRESTNotifications
2909 xapp.Logger.Debug("TEST: XAPP notification received e2SubsId=%v", e2SubsId)
2912 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2913 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2914 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2916 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsId.E2SubsId}, 10)
2918 mainCtrl.VerifyCounterValues(t)
2919 mainCtrl.VerifyAllClean(t)
2922 //-----------------------------------------------------------------------------
2924 // +-------+ +---------+ +---------+ +---------+
2925 // | xapp | | submgr | | e2term | | rtmgr |
2926 // +-------+ +---------+ +---------+ +---------+
2928 // | RESTSubReq | | |
2929 // |---------------->| | |
2930 // | RESTSubResp | | |
2931 // |<----------------| | |
2932 // | | RouteCreate | |
2933 // | |--------------------------->|
2934 // | | RouteResponse| |
2935 // | |<---------------------------| // The order of these events may vary
2937 // | |------------->| | // The order of these events may vary
2939 // | |<-------------| |
2940 // | RESTNotif1 | | |
2941 // |<----------------| | |
2942 // | RESTSubReq | | |
2943 // | [RETRANS1] | | |
2944 // |---------------->| | |
2945 // | RESTNotif1 | | |
2946 // |<----------------| | |
2947 // | RESTSubReq | | |
2948 // | [RETRANS2] | | |
2949 // |---------------->| | |
2950 // | RESTNotif1 | | |
2951 // |<----------------| | |
2952 // | RESTSubDelReq | | |
2953 // |---------------->| | |
2954 // | | SubDelReq | |
2955 // | |------------->| |
2956 // | RESTSubDelResp| | |
2957 // |<----------------| | |
2958 // | | SubDelResp | |
2959 // | |<-------------| |
2962 //-----------------------------------------------------------------------------
2964 func TestRESTSubReqRetransmissionV2(t *testing.T) {
2965 CaseBegin("TestRESTSubReqRetransmissionV2")
2967 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2968 Counter{cRestSubReqFromXapp, 3},
2969 Counter{cDuplicateE2SubReq, 2},
2970 Counter{cRestSubRespToXapp, 3},
2971 Counter{cSubReqToE2, 1},
2972 Counter{cSubRespFromE2, 1},
2973 Counter{cRestSubNotifToXapp, 3},
2974 Counter{cRestSubDelReqFromXapp, 1},
2975 Counter{cSubDelReqToE2, 1},
2976 Counter{cSubDelRespFromE2, 1},
2977 Counter{cRestSubDelRespToXapp, 1},
2980 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2982 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2984 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2987 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
2989 assert.Equal(t, restSubId_resend, restSubId)
2991 <-time.After(100 * time.Millisecond)
2994 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
2996 assert.Equal(t, restSubId_resend2, restSubId)
2998 <-time.After(100 * time.Millisecond)
3000 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3002 waitSubsCleanup(t, e2SubsId, 10)
3003 mainCtrl.VerifyCounterValues(t)
3004 mainCtrl.VerifyAllClean(t)
3007 //-----------------------------------------------------------------------------
3009 // +-------+ +---------+ +---------+ +---------+
3010 // | xapp | | submgr | | e2term | | rtmgr |
3011 // +-------+ +---------+ +---------+ +---------+
3013 // | RESTSubReq | | |
3014 // |---------------->| | |
3015 // | RESTSubResp | | |
3016 // |<----------------| | |
3017 // | | RouteCreate | |
3018 // | |--------------------------->|
3019 // | | RouteResponse| |
3020 // | |<---------------------------| // The order of these events may vary
3022 // | |------------->| | // The order of these events may vary
3024 // | |<-------------| |
3025 // | RESTNotif1 | | |
3026 // |<----------------| | |
3027 // | RESTSubReq | | |
3028 // | [RETRANS, with RESTsubsId] | |
3029 // |---------------->| | |
3030 // | RESTNotif1 | | |
3031 // |<----------------| | |
3032 // | RESTSubReq | | |
3033 // | [RETRANS, without RESTsubsId] | |
3034 // |---------------->| | |
3035 // | RESTNotif1 | | |
3036 // |<----------------| | |
3037 // | RESTSubDelReq | | |
3038 // |---------------->| | |
3039 // | | SubDelReq | |
3040 // | |------------->| |
3041 // | RESTSubDelResp| | |
3042 // |<----------------| | |
3043 // | | SubDelResp | |
3044 // | |<-------------| |
3047 //-----------------------------------------------------------------------------
3048 func TestRESTSubReqRetransmissionV3(t *testing.T) {
3049 CaseBegin("TestRESTSubReqRetransmissionV3")
3051 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3052 Counter{cRestSubReqFromXapp, 3},
3053 Counter{cDuplicateE2SubReq, 2},
3054 Counter{cRestSubRespToXapp, 3},
3055 Counter{cSubReqToE2, 1},
3056 Counter{cSubRespFromE2, 1},
3057 Counter{cRestSubNotifToXapp, 3},
3058 Counter{cRestSubDelReqFromXapp, 1},
3059 Counter{cSubDelReqToE2, 1},
3060 Counter{cSubDelRespFromE2, 1},
3061 Counter{cRestSubDelRespToXapp, 1},
3064 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3066 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3068 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3070 <-time.After(100 * time.Millisecond)
3072 //1.st resend with subscription ID
3073 params.SetSubscriptionID(&restSubId)
3074 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
3076 assert.Equal(t, restSubId_resend, restSubId)
3078 <-time.After(100 * time.Millisecond)
3080 //2.nd resend without subscription ID (faking app restart)
3081 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3082 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3084 assert.Equal(t, restSubId_resend2, restSubId)
3086 <-time.After(100 * time.Millisecond)
3088 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3090 waitSubsCleanup(t, e2SubsId, 10)
3091 mainCtrl.VerifyCounterValues(t)
3092 mainCtrl.VerifyAllClean(t)
3095 //-----------------------------------------------------------------------------
3097 // +-------+ +---------+ +---------+ +---------+
3098 // | xapp | | submgr | | e2term | | rtmgr |
3099 // +-------+ +---------+ +---------+ +---------+
3101 // | RESTSubReq | | |
3102 // |---------------->| | |
3103 // | RESTSubResp | | |
3104 // |<----------------| | |
3105 // | | RouteCreate | |
3106 // | |--------------------------->|
3107 // | | RouteResponse| |
3108 // | |<---------------------------|
3110 // | |------------->| |
3112 // | |<-------------| |
3113 // | RESTNotif1 | | |
3114 // |<----------------| | |
3115 // | RESTSubReq | | |
3116 // | [with RestSUbsId + one additional e2 subDetail]
3117 // |---------------->| | |
3118 // | RESTNotif1 | | |
3119 // | [for initial e2 subDetail] | |
3120 // |<----------------| | |
3121 // | | RouteCreate | |
3122 // | |--------------------------->|
3123 // | | RouteResponse| |
3124 // | |<---------------------------|
3126 // | |------------->| |
3128 // | |<-------------| |
3129 // | RESTNotif1 | | |
3130 // |<----------------| | |
3131 // | RESTSubReq | | |
3132 // | [with RESTsubsId initial request] |
3133 // |---------------->| | |
3134 // | RESTNotif1 | | |
3135 // |<----------------| | |
3136 // | RESTSubDelReq | | |
3137 // |---------------->| | |
3138 // | RESTSubDelResp| | |
3139 // |<----------------| | |
3140 // | | SubDelReq | |
3141 // | |------------->| |
3142 // | | SubDelResp | |
3143 // | |<-------------| |
3144 // | | SubDelReq | |
3145 // | |------------->| |
3146 // | | SubDelResp | |
3147 // | |<-------------| |
3150 //-----------------------------------------------------------------------------
3152 func TestRESTSubReqRetransmissionV4(t *testing.T) {
3153 CaseBegin("TestRESTSubReqRetransmissionV4")
3155 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3156 Counter{cRestSubReqFromXapp, 3},
3157 Counter{cDuplicateE2SubReq, 2},
3158 Counter{cRestSubRespToXapp, 3},
3159 Counter{cSubReqToE2, 2},
3160 Counter{cSubRespFromE2, 2},
3161 Counter{cRestSubNotifToXapp, 4},
3162 Counter{cRestSubDelReqFromXapp, 1},
3163 Counter{cSubDelReqToE2, 2},
3164 Counter{cSubDelRespFromE2, 2},
3165 Counter{cRestSubDelRespToXapp, 1},
3168 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3170 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3172 <-time.After(100 * time.Millisecond)
3174 // Send modified requst, this time with e2 subscriptions.
3175 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3176 params2.SetSubscriptionID(&restSubId)
3178 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3179 xappConn1.ExpectAnyNotification(t)
3180 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3181 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3182 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3183 assert.Equal(t, e2SubsId, e2SubsId1)
3185 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3187 xappConn1.DecrementRequestCount()
3188 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3189 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3190 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3191 assert.NotEqual(t, e2SubsId2, 0)
3193 <-time.After(100 * time.Millisecond)
3195 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3196 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3197 params.SetSubscriptionID(&restSubId)
3198 xappConn1.ExpectAnyNotification(t)
3199 // Resend the original request again with only one e2 subscription (detail), this time with restsubsid
3200 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3201 assert.Equal(t, restSubId_resend, restSubId_resend2)
3203 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3204 assert.Equal(t, e2SubsId, e2SubsId1)
3206 // Delete both e2 subscriptions
3207 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3208 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3209 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3211 waitSubsCleanup(t, e2SubsId, 10)
3212 mainCtrl.VerifyCounterValues(t)
3213 mainCtrl.VerifyAllClean(t)
3216 //-----------------------------------------------------------------------------
3218 // +-------+ +---------+ +---------+ +---------+
3219 // | xapp | | submgr | | e2term | | rtmgr |
3220 // +-------+ +---------+ +---------+ +---------+
3222 // | RESTSubReq | | |
3223 // |---------------->| | |
3224 // | RESTSubResp | | |
3225 // |<----------------| | |
3226 // | | RouteCreate | |
3227 // | |--------------------------->|
3228 // | | RouteResponse| |
3229 // | |<---------------------------|
3231 // | |------------->| |
3233 // | |<-------------| |
3234 // | RESTNotif1 | | |
3235 // |<----------------| | |
3236 // | RESTSubReq | | |
3237 // | [with RestSUbsId + one additional e2 subDetail]
3238 // |---------------->| | |
3239 // | RESTNotif1 | | |
3240 // | [for initial e2 subDetail] | |
3241 // |<----------------| | |
3242 // | | RouteCreate | |
3243 // | |--------------------------->|
3244 // | | RouteResponse| |
3245 // | |<---------------------------|
3247 // | |------------->| |
3249 // | |<-------------| |
3250 // | RESTNotif1 | | |
3251 // |<----------------| | |
3252 // | RESTSubReq | | |
3253 // | [without RESTsubsId initial request] |
3254 // |---------------->| | |
3255 // | RESTNotif1 | | |
3256 // |<----------------| | |
3257 // | RESTSubDelReq | | |
3258 // |---------------->| | |
3259 // | RESTSubDelResp| | |
3260 // |<----------------| | |
3261 // | | SubDelReq | |
3262 // | |------------->| |
3263 // | | SubDelResp | |
3264 // | |<-------------| |
3265 // | | SubDelReq | |
3266 // | |------------->| |
3267 // | | SubDelResp | |
3268 // | |<-------------| |
3271 //-----------------------------------------------------------------------------
3273 func TestRESTSubReqRetransmissionV5(t *testing.T) {
3274 CaseBegin("TestRESTSubReqRetransmissionV5")
3276 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3277 Counter{cRestSubReqFromXapp, 3},
3278 Counter{cDuplicateE2SubReq, 2},
3279 Counter{cRestSubRespToXapp, 3},
3280 Counter{cSubReqToE2, 2},
3281 Counter{cSubRespFromE2, 2},
3282 Counter{cRestSubNotifToXapp, 4},
3283 Counter{cRestSubDelReqFromXapp, 1},
3284 Counter{cSubDelReqToE2, 2},
3285 Counter{cSubDelRespFromE2, 2},
3286 Counter{cRestSubDelRespToXapp, 1},
3289 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3291 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3293 <-time.After(100 * time.Millisecond)
3295 // Send modified requst, this time with e2 subscriptions.
3296 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3297 params2.SetSubscriptionID(&restSubId)
3299 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3300 xappConn1.ExpectAnyNotification(t)
3301 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3302 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3304 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3305 assert.Equal(t, e2SubsId, e2SubsId1)
3306 // The first E2 subscription returns immediately, manually decrement expected request count for the remaining request handling
3307 xappConn1.DecrementRequestCount()
3309 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3311 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3312 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3313 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3314 assert.NotEqual(t, e2SubsId2, 0)
3316 <-time.After(100 * time.Millisecond)
3318 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3319 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3320 xappConn1.ExpectAnyNotification(t)
3321 // Resend the original request again with only one e2 subscription (detail), WITHOUT restsubsid
3322 // md5sum shall find the original request
3323 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3324 assert.Equal(t, restSubId_resend, restSubId_resend2)
3326 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3327 assert.Equal(t, e2SubsId, e2SubsId1)
3329 // Delete both e2 subscriptions
3330 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3331 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3332 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3334 waitSubsCleanup(t, e2SubsId, 10)
3335 mainCtrl.VerifyCounterValues(t)
3336 mainCtrl.VerifyAllClean(t)
3339 //-----------------------------------------------------------------------------
3341 // +-------+ +---------+ +---------+ +---------+
3342 // | xapp | | submgr | | e2term | | rtmgr |
3343 // +-------+ +---------+ +---------+ +---------+
3345 // | RESTSubReq | | |
3346 // |---------------->| | |
3347 // | RESTSubResp | | |
3348 // |<----------------| | |
3349 // | | RouteCreate | |
3350 // | |--------------------------->|
3351 // | | RouteResponse| |
3352 // | |<---------------------------|
3354 // | |------------->| |
3356 // | |<-------------| |
3357 // | RESTNotif1 | | |
3358 // |<----------------| | |
3359 // | RESTSubReq | | |
3360 // | [with RestSUbsId + one additional e2 subDetail]
3361 // |---------------->| | |
3362 // | RESTNotif1 | | |
3363 // | [for initial e2 subDetail] | |
3364 // |<----------------| | |
3365 // | | RouteCreate | |
3366 // | |--------------------------->|
3367 // | | RouteResponse| |
3368 // | |<---------------------------|
3370 // | |------------->| |
3372 // | |<-------------| |
3373 // | RESTNotif1 | | |
3374 // |<----------------| | |
3375 // | RESTSubDelReq | | |
3376 // |---------------->| | |
3377 // | RESTSubDelResp| | |
3378 // |<----------------| | |
3379 // | | SubDelReq | |
3380 // | |------------->| |
3381 // | | SubDelResp | |
3382 // | |<-------------| |
3383 // | | SubDelReq | |
3384 // | |------------->| |
3385 // | | SubDelResp | |
3386 // | |<-------------| |
3387 // | RESTSubReq | | |
3388 // | [with RESTsubsId initial request] |
3389 // |---------------->| | |
3390 // | RESTSubResp | | |
3391 // |<----------------| | |
3392 // | | RouteCreate | |
3393 // | |--------------------------->|
3394 // | | RouteResponse| |
3395 // | |<---------------------------|
3397 // | |------------->| |
3399 // | |<-------------| |
3400 // | RESTNotif1 | | |
3401 // |<----------------| | |
3404 //-----------------------------------------------------------------------------
3405 func TestRESTSubReqRetransmissionV6(t *testing.T) {
3406 CaseBegin("TestRESTSubReqRetransmissionV6")
3408 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3409 Counter{cRestSubReqFromXapp, 3},
3410 Counter{cDuplicateE2SubReq, 1},
3411 Counter{cRestSubRespToXapp, 3},
3412 Counter{cSubReqToE2, 3},
3413 Counter{cSubRespFromE2, 3},
3414 Counter{cRestSubNotifToXapp, 4},
3415 Counter{cRestSubDelReqFromXapp, 2},
3416 Counter{cSubDelReqToE2, 3},
3417 Counter{cSubDelRespFromE2, 3},
3418 Counter{cRestSubDelRespToXapp, 2},
3421 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3423 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3425 <-time.After(100 * time.Millisecond)
3427 // Send modified requst, this time with e2 subscriptions.
3428 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3429 params2.SetSubscriptionID(&restSubId)
3431 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3432 xappConn1.ExpectAnyNotification(t)
3433 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3434 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3436 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3437 assert.Equal(t, e2SubsId, e2SubsId1)
3439 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3441 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3442 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3443 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3444 assert.NotEqual(t, e2SubsId2, 0)
3446 <-time.After(100 * time.Millisecond)
3448 // Delete both e2 subscriptions
3449 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3450 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3451 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3453 waitSubsCleanup(t, e2SubsId, 10)
3455 // Resend the original request, we shall find it's previous md5sum/restsubs
3456 // but the restsubscription has been already removed. This shall trigger a
3458 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
3460 <-time.After(100 * time.Millisecond)
3462 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3464 waitSubsCleanup(t, e2SubsId, 10)
3465 mainCtrl.VerifyCounterValues(t)
3466 mainCtrl.VerifyAllClean(t)
3469 func TestRESTSubDelReqRetransmission(t *testing.T) {
3470 CaseBegin("TestRESTSubDelReqRetransmission")
3472 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3473 Counter{cRestSubReqFromXapp, 1},
3474 Counter{cRestSubRespToXapp, 1},
3475 Counter{cSubReqToE2, 1},
3476 Counter{cSubRespFromE2, 1},
3477 Counter{cRestSubNotifToXapp, 1},
3478 Counter{cRestSubDelReqFromXapp, 2},
3479 Counter{cSubDelReqToE2, 1},
3480 Counter{cSubDelRespFromE2, 1},
3481 Counter{cRestSubDelRespToXapp, 2},
3484 var params *teststube2ap.RESTSubsReqParams = nil
3487 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3489 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3492 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3493 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3495 seqBef := mainCtrl.get_msgcounter(t)
3496 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3497 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
3499 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3501 waitSubsCleanup(t, e2SubsId, 10)
3502 mainCtrl.VerifyCounterValues(t)
3503 mainCtrl.VerifyAllClean(t)
3506 //-----------------------------------------------------------------------------
3507 // TestRESTSubReqDelReq
3510 // +-------+ +---------+ +---------+
3511 // | xapp | | submgr | | e2term |
3512 // +-------+ +---------+ +---------+
3515 // |---------------->| |
3517 // | RESTSubResp | |
3518 // |<----------------| |
3520 // | |------------->|
3521 // | RESTSubDelReq | |
3522 // |---------------->| |
3523 // | RESTSubDelResp | |
3525 // |<----------------| |
3527 // | |<-------------|
3529 // |<----------------| |
3531 // | [SUBS DELETE] |
3534 //-----------------------------------------------------------------------------
3535 func TestRESTSubReqDelReq(t *testing.T) {
3536 CaseBegin("TestRESTSubReqDelReq")
3538 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3539 Counter{cRestSubReqFromXapp, 1},
3540 Counter{cRestSubRespToXapp, 1},
3541 Counter{cSubReqToE2, 1},
3542 Counter{cSubRespFromE2, 1},
3543 Counter{cRestSubNotifToXapp, 1},
3544 Counter{cRestSubDelReqFromXapp, 2},
3545 Counter{cRestSubDelFailToXapp, 1},
3546 Counter{cSubDelReqToE2, 1},
3547 Counter{cSubDelRespFromE2, 1},
3548 Counter{cRestSubDelRespToXapp, 1},
3551 const subReqCount int = 1
3554 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3555 restSubId := xappConn1.SendRESTSubsReq(t, params)
3557 // Del. This will fail as processing of the subscription
3558 // is still ongoing in submgr. Deletion is not allowed before
3559 // subscription creation has been completed.
3560 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3561 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3562 xappConn1.ExpectRESTNotification(t, restSubId)
3563 e2termConn1.SendSubsResp(t, crereq, cremsg)
3564 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3567 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3569 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3570 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3572 // Wait that subs is cleaned
3573 waitSubsCleanup(t, e2SubsId, 10)
3574 mainCtrl.VerifyCounterValues(t)
3575 mainCtrl.VerifyAllClean(t)
3578 func TestRESTSubDelReqCollision(t *testing.T) {
3579 CaseBegin("TestRESTSubDelReqCollision - not relevant for REST API")
3582 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
3583 CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel")
3585 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3586 Counter{cRestSubReqFromXapp, 2},
3587 Counter{cRestSubRespToXapp, 2},
3588 Counter{cSubReqToE2, 2},
3589 Counter{cSubRespFromE2, 2},
3590 Counter{cRestSubNotifToXapp, 2},
3591 Counter{cRestSubDelReqFromXapp, 2},
3592 Counter{cSubDelReqToE2, 2},
3593 Counter{cSubDelRespFromE2, 2},
3594 Counter{cRestSubDelRespToXapp, 2},
3598 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3599 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3600 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3603 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3604 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3605 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3607 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3608 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3610 //XappConn1 receives both of the responses
3611 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3614 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3616 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3618 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3619 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3620 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3621 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3624 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3626 deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
3628 //Wait that subs is cleaned
3629 mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
3630 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
3632 mainCtrl.VerifyCounterValues(t)
3633 mainCtrl.VerifyAllClean(t)
3636 func TestRESTSameSubsDiffRan(t *testing.T) {
3637 CaseBegin("TestRESTSameSubsDiffRan")
3639 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3640 Counter{cRestSubReqFromXapp, 2},
3641 Counter{cRestSubRespToXapp, 2},
3642 Counter{cSubReqToE2, 2},
3643 Counter{cSubRespFromE2, 2},
3644 Counter{cRestSubNotifToXapp, 2},
3645 Counter{cRestSubDelReqFromXapp, 2},
3646 Counter{cSubDelReqToE2, 2},
3647 Counter{cSubDelRespFromE2, 2},
3648 Counter{cRestSubDelRespToXapp, 2},
3651 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3652 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3653 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3655 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3656 params.SetMeid("RAN_NAME_2")
3657 restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
3658 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3661 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3663 deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
3665 //Wait that subs is cleaned
3666 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3667 waitSubsCleanup(t, e2SubsId2, 10)
3669 mainCtrl.VerifyCounterValues(t)
3670 mainCtrl.VerifyAllClean(t)
3673 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
3674 CaseBegin("TestRESTSubReqRetryInSubmgr start")
3676 // Init counter check
3677 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3678 Counter{cRestSubReqFromXapp, 1},
3679 Counter{cRestSubRespToXapp, 1},
3680 Counter{cSubReqToE2, 1},
3681 Counter{cSubReqTimerExpiry, 1},
3682 Counter{cSubReReqToE2, 1},
3683 Counter{cSubRespFromE2, 1},
3684 Counter{cRestSubNotifToXapp, 1},
3685 Counter{cRestSubDelReqFromXapp, 1},
3686 Counter{cSubDelReqToE2, 1},
3687 Counter{cSubDelRespFromE2, 1},
3688 Counter{cRestSubDelRespToXapp, 1},
3691 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3692 restSubId := xappConn1.SendRESTSubsReq(t, params)
3694 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3696 // Catch the first message and ignore it
3697 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3698 xapp.Logger.Debug("Ignore REST subscriber request for subscriber : %v", restSubId)
3700 // The second request is being handled normally
3701 crereq, cremsg = e2termConn1.RecvSubsReq(t)
3702 xappConn1.ExpectRESTNotification(t, restSubId)
3703 e2termConn1.SendSubsResp(t, crereq, cremsg)
3704 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3706 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3708 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3710 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
3711 //Wait that subs is cleaned
3712 waitSubsCleanup(t, e2SubsId, 10)
3714 mainCtrl.VerifyCounterValues(t)
3715 mainCtrl.VerifyAllClean(t)
3718 //-----------------------------------------------------------------------------
3719 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3722 // +-------+ +---------+ +---------+
3723 // | xapp | | submgr | | e2term |
3724 // +-------+ +---------+ +---------+
3727 // |---------------->| |
3729 // | RESTSubResp | |
3730 // |<----------------| |
3732 // | |------------->|
3736 // | |------------->|
3739 // | |------------->|
3743 // | |------------->|
3747 // | |<-------------|
3750 // |<----------------| |
3752 // | [SUBS DELETE] |
3755 //-----------------------------------------------------------------------------
3757 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
3758 CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
3760 // Init counter check
3761 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3762 Counter{cRestSubReqFromXapp, 1},
3763 Counter{cRestSubRespToXapp, 1},
3764 Counter{cSubReqToE2, 1},
3765 Counter{cSubReReqToE2, 1},
3766 Counter{cSubReqTimerExpiry, 2},
3767 Counter{cRestSubFailNotifToXapp, 1},
3768 Counter{cSubDelReqToE2, 1},
3769 Counter{cSubDelRespFromE2, 1},
3770 Counter{cRestSubDelReqFromXapp, 1},
3771 Counter{cRestSubDelRespToXapp, 1},
3774 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3775 restSubId := xappConn1.SendRESTSubsReq(t, params)
3776 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3778 e2termConn1.RecvSubsReq(t)
3779 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3781 e2termConn1.RecvSubsReq(t)
3782 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3784 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3785 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3786 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3787 xappConn1.WaitRESTNotification(t, restSubId)
3789 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3791 // Wait that subs is cleaned
3792 waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
3793 mainCtrl.VerifyCounterValues(t)
3794 mainCtrl.VerifyAllClean(t)
3797 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
3798 CaseBegin("TestREST2eTermNotRespondingToSubReq start")
3800 // Init counter check
3801 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3802 Counter{cRestSubReqFromXapp, 1},
3803 Counter{cRestSubRespToXapp, 1},
3804 Counter{cSubReqToE2, 1},
3805 Counter{cSubReReqToE2, 1},
3806 Counter{cSubReqTimerExpiry, 2},
3807 Counter{cSubDelReReqToE2, 1},
3808 Counter{cRestSubFailNotifToXapp, 1},
3809 Counter{cSubDelReqToE2, 1},
3810 Counter{cSubDelReqTimerExpiry, 2},
3811 Counter{cRestSubDelReqFromXapp, 1},
3812 Counter{cRestSubDelRespToXapp, 1},
3815 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3816 restSubId := xappConn1.SendRESTSubsReq(t, params)
3817 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3819 e2termConn1.RecvSubsReq(t)
3820 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3822 e2termConn1.RecvSubsReq(t)
3823 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3825 e2termConn1.RecvSubsDelReq(t)
3826 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3828 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3829 e2termConn1.RecvSubsDelReq(t)
3830 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3832 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3834 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3836 waitSubsCleanup(t, e2SubsId, 10)
3837 mainCtrl.VerifyCounterValues(t)
3838 mainCtrl.VerifyAllClean(t)
3841 //-----------------------------------------------------------------------------
3842 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3845 // +-------+ +---------+ +---------+
3846 // | xapp | | submgr | | e2term |
3847 // +-------+ +---------+ +---------+
3850 // |---------------->| |
3852 // | RESTSubResp | |
3853 // |<----------------| |
3855 // | |------------->|
3859 // | |------------->|
3862 // | |------------->|
3866 // | |------------->|
3870 // | |<-------------|
3873 // |<----------------| |
3875 // | [SUBS DELETE] |
3878 //-----------------------------------------------------------------------------
3879 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
3880 CaseBegin("TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr start")
3882 // Init counter check
3883 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3884 Counter{cRestSubReqFromXapp, 1},
3885 Counter{cRestSubRespToXapp, 1},
3886 Counter{cSubReqToE2, 1},
3887 Counter{cSubReReqToE2, 1},
3888 Counter{cSubReqTimerExpiry, 2},
3889 Counter{cRestSubFailNotifToXapp, 1},
3890 Counter{cSubDelReqToE2, 1},
3891 Counter{cSubDelReReqToE2, 1},
3892 Counter{cSubDelReqTimerExpiry, 2},
3893 Counter{cRestSubDelReqFromXapp, 1},
3894 Counter{cRestSubDelRespToXapp, 1},
3897 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3898 restSubId := xappConn1.SendRESTSubsReq(t, params)
3899 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3901 e2termConn1.RecvSubsReq(t)
3902 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3904 e2termConn1.RecvSubsReq(t)
3905 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3907 e2termConn1.RecvSubsDelReq(t)
3908 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3910 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3911 e2termConn1.RecvSubsDelReq(t)
3912 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3914 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3916 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3918 waitSubsCleanup(t, e2SubsId, 10)
3919 mainCtrl.VerifyCounterValues(t)
3920 mainCtrl.VerifyAllClean(t)
3923 //-----------------------------------------------------------------------------
3924 // TestRESTSubReqSubFailRespInSubmgr
3927 // +-------+ +---------+ +---------+
3928 // | xapp | | submgr | | e2term |
3929 // +-------+ +---------+ +---------+
3932 // |---------------->| |
3934 // | RESTSubResp | |
3935 // |<----------------| |
3937 // | |------------->|
3940 // | |<-------------|
3944 // |<----------------| |
3946 // | [SUBS DELETE] |
3949 //-----------------------------------------------------------------------------
3950 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
3951 CaseBegin("TestRESTSubReqSubFailRespInSubmgr")
3953 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3954 Counter{cRestSubReqFromXapp, 1},
3955 Counter{cRestSubRespToXapp, 1},
3956 Counter{cSubReqToE2, 1},
3957 Counter{cSubFailFromE2, 1},
3958 Counter{cRestSubFailNotifToXapp, 1},
3959 Counter{cRestSubDelReqFromXapp, 1},
3960 Counter{cRestSubDelRespToXapp, 1},
3963 const subReqCount int = 1
3964 const e2Timeout int64 = 2
3965 const e2RetryCount int64 = 1
3966 const routingNeeded bool = true
3968 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3969 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
3970 restSubId := xappConn1.SendRESTSubsReq(t, params)
3972 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3973 fparams1 := &teststube2ap.E2StubSubsFailParams{}
3974 fparams1.Set(crereq1)
3975 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3976 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3978 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3979 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
3981 // REST subscription sill there to be deleted
3982 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3984 // Wait that subs is cleaned
3985 waitSubsCleanup(t, e2SubsId, 10)
3987 mainCtrl.VerifyCounterValues(t)
3988 mainCtrl.VerifyAllClean(t)
3991 //-----------------------------------------------------------------------------
3992 // TestRESTSubDelReqRetryInSubmgr
3995 // +-------+ +---------+ +---------+
3996 // | xapp | | submgr | | e2term |
3997 // +-------+ +---------+ +---------+
3999 // | [SUBS CREATE] |
4002 // | RESTSubDelReq | |
4003 // |---------------->| |
4005 // | RESTSubDelResp | |
4006 // |<----------------| |
4008 // | |------------->|
4011 // | |------------->|
4014 // | |<-------------|
4017 //-----------------------------------------------------------------------------
4018 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
4019 CaseBegin("TestRESTSubDelReqRetryInSubmgr")
4021 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4022 Counter{cRestSubReqFromXapp, 1},
4023 Counter{cRestSubRespToXapp, 1},
4024 Counter{cSubReqToE2, 1},
4025 Counter{cSubRespFromE2, 1},
4026 Counter{cRestSubNotifToXapp, 1},
4027 Counter{cRestSubDelReqFromXapp, 1},
4028 Counter{cSubDelReqToE2, 1},
4029 Counter{cSubDelReqTimerExpiry, 1},
4030 Counter{cSubDelReReqToE2, 1},
4031 Counter{cSubDelRespFromE2, 1},
4032 Counter{cRestSubDelRespToXapp, 1},
4035 var params *teststube2ap.RESTSubsReqParams = nil
4036 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4039 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4041 // E2t: Receive 1st SubsDelReq
4042 e2termConn1.RecvSubsDelReq(t)
4044 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4045 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4046 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4048 //Wait that subs is cleaned
4049 waitSubsCleanup(t, e2SubsId, 10)
4051 mainCtrl.VerifyCounterValues(t)
4052 mainCtrl.VerifyAllClean(t)
4055 //-----------------------------------------------------------------------------
4056 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
4059 // +-------+ +---------+ +---------+
4060 // | xapp | | submgr | | e2term |
4061 // +-------+ +---------+ +---------+
4063 // | [SUBS CREATE] |
4066 // | RESTSubDelReq | |
4067 // |---------------->| |
4069 // | RESTSubDelResp | |
4070 // |<----------------| |
4072 // | |------------->|
4075 // | |------------->|
4079 //-----------------------------------------------------------------------------
4080 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
4081 CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr")
4083 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4084 Counter{cRestSubReqFromXapp, 1},
4085 Counter{cRestSubRespToXapp, 1},
4086 Counter{cSubReqToE2, 1},
4087 Counter{cSubRespFromE2, 1},
4088 Counter{cRestSubNotifToXapp, 1},
4089 Counter{cRestSubDelReqFromXapp, 1},
4090 Counter{cSubDelReqToE2, 1},
4091 Counter{cSubDelReqTimerExpiry, 1},
4092 Counter{cSubDelReReqToE2, 1},
4093 Counter{cSubDelRespFromE2, 1},
4094 Counter{cRestSubDelRespToXapp, 1},
4098 var params *teststube2ap.RESTSubsReqParams = nil
4099 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4102 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4104 // E2t: Receive 1st SubsDelReq
4105 e2termConn1.RecvSubsDelReq(t)
4107 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4108 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4109 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4111 //Wait that subs is cleaned
4112 waitSubsCleanup(t, e2SubsId, 10)
4114 mainCtrl.VerifyCounterValues(t)
4115 mainCtrl.VerifyAllClean(t)
4118 //-----------------------------------------------------------------------------
4119 // TestRESTSubDelReqSubDelFailRespInSubmgr
4122 // +-------+ +---------+ +---------+
4123 // | xapp | | submgr | | e2term |
4124 // +-------+ +---------+ +---------+
4126 // | [SUBS CREATE] |
4129 // | RESTSubDelReq | |
4130 // |---------------->| |
4132 // | RESTSubDelResp | |
4133 // |<----------------| |
4135 // | |------------->|
4138 // | |<-------------|
4141 //-----------------------------------------------------------------------------
4142 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
4143 CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr")
4145 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4146 Counter{cRestSubReqFromXapp, 1},
4147 Counter{cRestSubRespToXapp, 1},
4148 Counter{cSubReqToE2, 1},
4149 Counter{cSubRespFromE2, 1},
4150 Counter{cRestSubNotifToXapp, 1},
4151 Counter{cRestSubDelReqFromXapp, 1},
4152 Counter{cSubDelReqToE2, 1},
4153 Counter{cSubDelFailFromE2, 1},
4154 Counter{cRestSubDelRespToXapp, 1},
4158 var params *teststube2ap.RESTSubsReqParams = nil
4159 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4162 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4164 // E2t: Send receive SubsDelReq and send SubsDelFail
4165 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4166 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
4168 //Wait that subs is cleaned
4169 waitSubsCleanup(t, e2SubsId, 10)
4171 mainCtrl.VerifyCounterValues(t)
4172 mainCtrl.VerifyAllClean(t)
4175 //-----------------------------------------------------------------------------
4176 // TestRESTSubReqAndSubDelOkSameAction
4179 // +-------+ +-------+ +---------+ +---------+
4180 // | xapp2 | | xapp1 | | submgr | | e2term |
4181 // +-------+ +-------+ +---------+ +---------+
4183 // | | RESTSubReq1 | |
4184 // | |---------------->| |
4186 // | | RESTSubResp1 | |
4187 // | |<----------------| |
4190 // | | |------------->|
4192 // | | |<-------------|
4193 // | | RESTNotif1 | |
4194 // | |<----------------| |
4196 // | RESTSubReq2 | |
4197 // |------------------------------>| |
4199 // | RESTSubResp2 | |
4200 // |<------------------------------| |
4202 // | | RESTNotif2 | |
4203 // |<------------------------------| |
4205 // | | RESTSubDelReq1 | |
4206 // | |---------------->| |
4208 // | | RESTSubDelResp1 | |
4209 // | |<----------------| |
4211 // | RESTSubDelReq2 | |
4212 // |------------------------------>| |
4214 // | RESTSubDelResp2 | |
4215 // |<------------------------------| |
4217 // | | | SubDelReq2 |
4218 // | | |------------->|
4220 // | | | SubDelResp2 |
4221 // | | |<-------------|
4224 //-----------------------------------------------------------------------------
4225 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
4226 CaseBegin("TestRESTSubReqAndSubDelOkSameAction")
4228 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4229 Counter{cRestSubReqFromXapp, 2},
4230 Counter{cRestSubRespToXapp, 2},
4231 Counter{cSubReqToE2, 1},
4232 Counter{cSubRespFromE2, 1},
4233 Counter{cRestSubNotifToXapp, 2},
4234 Counter{cMergedSubscriptions, 1},
4235 Counter{cUnmergedSubscriptions, 1},
4236 Counter{cRestSubDelReqFromXapp, 2},
4237 Counter{cSubDelReqToE2, 1},
4238 Counter{cSubDelRespFromE2, 1},
4239 Counter{cRestSubDelRespToXapp, 2},
4243 var params *teststube2ap.RESTSubsReqParams = nil
4246 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4247 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4250 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4251 params.SetMeid("RAN_NAME_1")
4253 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4254 xappConn2.ExpectAnyNotification(t)
4255 waiter := rtmgrHttp.AllocNextSleep(10, true)
4256 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4257 waiter.WaitResult(t)
4258 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
4259 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
4260 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
4262 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
4265 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4268 deleteXapp2Subscription(t, &restSubId2)
4270 //Wait that subs is cleaned
4271 waitSubsCleanup(t, e2SubsId2, 10)
4272 mainCtrl.VerifyCounterValues(t)
4273 mainCtrl.VerifyAllClean(t)
4276 //-----------------------------------------------------------------------------
4277 // TestSubReqAndSubDelOkSameActionParallel
4280 // +-------+ +-------+ +---------+ +---------+
4281 // | xapp2 | | xapp1 | | submgr | | e2term |
4282 // +-------+ +-------+ +---------+ +---------+
4287 // | |------------->| |
4290 // | | |------------->|
4292 // |--------------------------->| |
4294 // | | |<-------------|
4296 // | |<-------------| |
4298 // | | |------------->|
4301 // | | |<-------------|
4303 // |<---------------------------| |
4305 // | | SubDelReq 1 | |
4306 // | |------------->| |
4308 // | | SubDelResp 1 | |
4309 // | |<-------------| |
4311 // | SubDelReq 2 | |
4312 // |--------------------------->| |
4314 // | | | SubDelReq 2 |
4315 // | | |------------->|
4317 // | | | SubDelReq 2 |
4318 // | | |------------->|
4320 // | SubDelResp 2 | |
4321 // |<---------------------------| |
4323 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
4324 CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel")
4326 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4327 Counter{cRestSubReqFromXapp, 2},
4328 Counter{cRestSubRespToXapp, 2},
4329 Counter{cSubReqToE2, 2},
4330 Counter{cSubRespFromE2, 2},
4331 Counter{cRestSubNotifToXapp, 2},
4332 Counter{cRestSubDelReqFromXapp, 2},
4333 Counter{cSubDelReqToE2, 2},
4334 Counter{cSubDelRespFromE2, 2},
4335 Counter{cRestSubDelRespToXapp, 2},
4338 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4339 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4340 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4342 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4343 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4345 xappConn1.ExpectRESTNotification(t, restSubId1)
4346 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4347 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4349 xappConn2.ExpectRESTNotification(t, restSubId2)
4350 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
4351 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
4352 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4355 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4356 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4357 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4358 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4361 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4362 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
4363 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
4365 waitSubsCleanup(t, e2SubsId2, 10)
4366 mainCtrl.VerifyCounterValues(t)
4367 mainCtrl.VerifyAllClean(t)
4370 //-----------------------------------------------------------------------------
4371 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
4374 // +-------+ +-------+ +---------+ +---------+
4375 // | xapp2 | | xapp1 | | submgr | | e2term |
4376 // +-------+ +-------+ +---------+ +---------+
4380 // | | RESTSubReq1 | |
4381 // | |---------------->| |
4383 // | | RESTSubResp1 | |
4384 // | |<----------------| |
4386 // | | |------------->|
4387 // | RESTSubReq2 | |
4388 // |------------------------------>| |
4390 // | RESTSubResp2 | |
4391 // |<------------------------------| |
4393 // | | |------------->|
4396 // | | | SubDelReq |
4397 // | | |------------->|
4399 // | | | SubDelResp |
4400 // | | |<-------------|
4401 // | | RESTNotif1 | |
4402 // | | unsuccess | |
4403 // | |<----------------| |
4405 // | | unsuccess | |
4406 // |<------------------------------| |
4408 // | | RESTSubDelReq1 | |
4409 // | |---------------->| |
4411 // | | RESTSubDelResp1 | |
4412 // | |<----------------| |
4414 // | RESTSubDelReq2 | |
4415 // |------------------------------>| |
4417 // | RESTSubDelResp2 | |
4418 // |<------------------------------| |
4420 //-----------------------------------------------------------------------------
4421 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
4422 CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
4424 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4425 Counter{cRestSubReqFromXapp, 2},
4426 Counter{cMergedSubscriptions, 1},
4427 Counter{cRestSubRespToXapp, 2},
4428 Counter{cSubReqToE2, 1},
4429 Counter{cSubReqTimerExpiry, 2},
4430 Counter{cSubReReqToE2, 1},
4431 Counter{cRestSubFailNotifToXapp, 2},
4432 Counter{cUnmergedSubscriptions, 1},
4433 Counter{cRestSubDelReqFromXapp, 2},
4434 Counter{cSubDelReqToE2, 1},
4435 Counter{cSubDelRespFromE2, 1},
4436 Counter{cRestSubDelRespToXapp, 2},
4438 const subReqCount int = 1
4441 params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4442 restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
4443 crereq1, _ := e2termConn1.RecvSubsReq(t)
4446 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4447 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4448 params2.SetMeid("RAN_NAME_1")
4449 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4450 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4452 //Req1 (retransmitted)
4453 e2termConn1.RecvSubsReq(t)
4455 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4457 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4458 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4460 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4461 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4462 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4463 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4466 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4469 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4471 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
4473 //Wait that subs is cleaned
4474 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4475 mainCtrl.VerifyCounterValues(t)
4476 mainCtrl.VerifyAllClean(t)
4479 //-----------------------------------------------------------------------------
4480 // TestRESTSubReqAndSubDelNokSameActionParallel
4483 // +-------+ +-------+ +---------+ +---------+
4484 // | xapp2 | | xapp1 | | submgr | | e2term |
4485 // +-------+ +-------+ +---------+ +---------+
4489 // | | RESTSubReq1 | |
4490 // | |---------------->| |
4492 // | | RESTSubResp1 | |
4493 // | |<----------------| |
4495 // | | |------------->|
4496 // | RESTSubReq2 | |
4497 // |------------------------------>| |
4499 // | RESTSubDelResp2 | |
4500 // |<------------------------------| |
4502 // | | |<-------------|
4504 // | | RESTNotif1 | |
4505 // | | unsuccess | |
4506 // | |<----------------| |
4508 // | | unsuccess | |
4509 // |<------------------------------| |
4511 // | | RESTSubDelReq1 | | There is no need for xApp to send delete for failed subscriptions but some xApp might do so.
4512 // | |---------------->| |
4514 // | | RESTSubDelResp1 | |
4515 // | |<----------------| |
4517 // | RESTSubDelReq2 | |
4518 // |------------------------------>| |
4520 // | RESTSubDelResp2 | |
4521 // |<------------------------------| |
4523 //-----------------------------------------------------------------------------
4524 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
4525 CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
4527 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4528 Counter{cRestSubReqFromXapp, 2},
4529 Counter{cMergedSubscriptions, 1},
4530 Counter{cRestSubRespToXapp, 2},
4531 Counter{cSubReqToE2, 1},
4532 Counter{cSubFailFromE2, 1},
4533 Counter{cRestSubFailNotifToXapp, 2},
4534 Counter{cUnmergedSubscriptions, 1},
4535 Counter{cRestSubDelReqFromXapp, 2},
4536 Counter{cRestSubDelRespToXapp, 2},
4539 const subReqCount int = 1
4542 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4543 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4544 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4547 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4548 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4549 params2.SetMeid("RAN_NAME_1")
4550 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4551 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4553 // E2t: send SubsFail (first)
4554 fparams1 := &teststube2ap.E2StubSubsFailParams{}
4555 fparams1.Set(crereq1)
4556 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
4558 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4559 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4560 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4561 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4562 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4565 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4568 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4570 //Wait that subs is cleaned
4571 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4572 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
4573 mainCtrl.VerifyCounterValues(t)
4574 mainCtrl.VerifyAllClean(t)
4577 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
4578 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4580 // Init counter check
4581 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4582 Counter{cRestSubReqFromXapp, 1},
4583 Counter{cRestSubRespToXapp, 1},
4584 Counter{cSubReqToE2, 1},
4585 Counter{cSubRespFromE2, 1},
4586 Counter{cRestSubNotifToXapp, 1},
4587 Counter{cRestSubDelReqFromXapp, 1},
4588 Counter{cSubDelReqToE2, 1},
4589 Counter{cSubDelRespFromE2, 1},
4590 Counter{cRestSubDelRespToXapp, 1},
4593 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4594 restSubId := xappConn1.SendRESTSubsReq(t, params)
4595 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
4597 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4598 xappConn1.ExpectRESTNotification(t, restSubId)
4599 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4600 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4601 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
4603 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4604 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4605 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4607 // Wait that subs is cleaned
4608 waitSubsCleanup(t, e2SubsId, 10)
4609 mainCtrl.VerifyCounterValues(t)
4610 mainCtrl.VerifyAllClean(t)
4613 //-----------------------------------------------------------------------------
4614 // TestRESTSubReqPolicyChangeAndSubDelOk
4617 // +-------+ +---------+ +---------+
4618 // | xapp | | submgr | | e2term |
4619 // +-------+ +---------+ +---------+
4622 // |---------------->| |
4624 // | RESTSubResp | |
4625 // |<----------------| |
4627 // | |------------->|
4630 // | |<-------------|
4633 // |<----------------| |
4636 // |---------------->| |
4638 // | RESTSubResp | |
4639 // |<----------------| |
4641 // | |------------->|
4644 // | |<-------------|
4647 // |<----------------| |
4649 // | RESTSubDelReq | |
4650 // |---------------->| |
4653 // | |------------->|
4656 // | |<-------------|
4658 // | RESTSubDelResp | |
4659 // |<----------------| |
4661 //-----------------------------------------------------------------------------
4662 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
4663 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4665 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4666 Counter{cRestSubReqFromXapp, 2},
4667 Counter{cRestSubRespToXapp, 2},
4668 Counter{cSubReqToE2, 2},
4669 Counter{cSubRespFromE2, 2},
4670 Counter{cRestSubNotifToXapp, 2},
4671 Counter{cRestSubDelReqFromXapp, 1},
4672 Counter{cSubDelReqToE2, 1},
4673 Counter{cSubDelRespFromE2, 1},
4674 Counter{cRestSubDelRespToXapp, 1},
4677 const subReqCount int = 1
4678 const e2Timeout int64 = 1
4679 const e2RetryCount int64 = 0
4680 const routingNeeded bool = true
4683 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4684 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4685 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4688 // GetRESTSubsReqPolicyParams sets some counters on tc side.
4690 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4691 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4692 params.SetSubscriptionID(&restSubId)
4693 params.SetTimeToWait("w200ms")
4694 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
4697 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4699 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4700 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4702 // Wait that subs is cleaned
4703 waitSubsCleanup(t, e2SubsId, 10)
4704 mainCtrl.VerifyCounterValues(t)
4705 mainCtrl.VerifyAllClean(t)
4708 //-----------------------------------------------------------------------------
4709 // TestRESTSubReqPolicyChangeNOk
4712 // +-------+ +---------+ +---------+
4713 // | xapp | | submgr | | e2term |
4714 // +-------+ +---------+ +---------+
4717 // |---------------->| |
4719 // | RESTSubResp | |
4720 // |<----------------| |
4722 // | |------------->|
4725 // | |<-------------|
4728 // |<----------------| |
4731 // |---------------->| |
4733 // | RESTSubUpdateFail(400 Bad request)
4735 // | RESTSubDelReq | |
4736 // |---------------->| |
4739 // | |------------->|
4742 // | |<-------------|
4744 // | RESTSubDelResp | |
4745 // |<----------------| |
4747 //-----------------------------------------------------------------------------
4748 func TestRESTSubReqPolicyChangeNOk(t *testing.T) {
4749 CaseBegin("TestRESTSubReqPolicyChangeNOk")
4751 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4752 Counter{cRestSubReqFromXapp, 2},
4753 Counter{cRestSubRespToXapp, 1},
4754 Counter{cSubReqToE2, 1},
4755 Counter{cSubRespFromE2, 1},
4756 Counter{cRestSubNotifToXapp, 1},
4757 Counter{cRestSubFailToXapp, 1},
4758 Counter{cRestSubDelReqFromXapp, 1},
4759 Counter{cSubDelReqToE2, 1},
4760 Counter{cSubDelRespFromE2, 1},
4761 Counter{cRestSubDelRespToXapp, 1},
4765 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4766 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4769 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4771 restSubIdUpd := strings.ToUpper(restSubId) // This makes RESTSubReq to fail
4772 params.SetSubscriptionID(&restSubIdUpd)
4773 params.SetTimeToWait("w200ms")
4775 restSubId2 := xappConn1.SendRESTSubsReq(t, params)
4776 assert.Equal(t, restSubId2, "")
4779 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4781 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4782 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4784 // Wait that subs is cleaned
4785 waitSubsCleanup(t, e2SubsId, 10)
4786 mainCtrl.VerifyCounterValues(t)
4787 mainCtrl.VerifyAllClean(t)
4790 //-----------------------------------------------------------------------------
4791 // TestRESTSubReqAndSubDelOkTwoE2termParallel
4794 // +-------+ +---------+ +---------+ +---------+
4795 // | xapp | | submgr | | e2term1 | | e2term2 |
4796 // +-------+ +---------+ +---------+ +---------+
4800 // | RESTSubReq1 | | |
4801 // |---------------->| | |
4803 // | RESTSubResp1 | | |
4804 // |<----------------| | |
4806 // | |------------->| |
4808 // | RESTSubReq2 | | |
4809 // |---------------->| | |
4811 // | RESTSubResp2 | | |
4812 // |<----------------| | |
4814 // | |---------------------------->|
4817 // | |<-------------| |
4818 // | RESTNotif1 | | |
4819 // |<----------------| | |
4821 // | |<----------------------------|
4822 // | RESTNotif2 | | |
4823 // |<----------------| | |
4825 // | [SUBS 1 DELETE] | |
4827 // | [SUBS 2 DELETE] | |
4830 //-----------------------------------------------------------------------------
4831 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
4832 CaseBegin("TestRESTSubReqAndSubDelOkTwoE2termParallel")
4834 // Init counter check
4835 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4836 Counter{cRestSubReqFromXapp, 2},
4837 Counter{cRestSubRespToXapp, 2},
4838 Counter{cSubReqToE2, 2},
4839 Counter{cSubRespFromE2, 2},
4840 Counter{cRestSubNotifToXapp, 2},
4841 Counter{cRestSubDelReqFromXapp, 2},
4842 Counter{cSubDelReqToE2, 2},
4843 Counter{cSubDelRespFromE2, 2},
4844 Counter{cRestSubDelRespToXapp, 2},
4847 const subReqCount int = 1
4850 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4851 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4852 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4855 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4856 params.SetMeid("RAN_NAME_11")
4857 // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
4858 // would not work as notification would not be received
4859 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4860 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
4863 xappConn1.ExpectRESTNotification(t, restSubId1)
4864 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4865 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4866 xapp.Logger.Debug("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
4869 xappConn2.ExpectRESTNotification(t, restSubId2)
4870 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
4871 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4872 xapp.Logger.Debug("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
4875 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4876 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4877 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4879 // Wait that subs is cleaned
4880 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4883 xappConn1.SendRESTSubsDelReq(t, &restSubId2)
4884 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
4885 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
4887 // Wait that subs is cleaned
4888 waitSubsCleanup(t, e2SubsId2, 10)
4890 mainCtrl.VerifyCounterValues(t)
4891 mainCtrl.VerifyAllClean(t)
4894 //-----------------------------------------------------------------------------
4895 // TestRESTSubReqAsn1EncodeFail
4897 // In this case submgr send RICSubscriptionDeleteRequest after encode failure which should not happen!
4899 // +-------+ +---------+ +---------+
4900 // | xapp | | submgr | | e2term |
4901 // +-------+ +---------+ +---------+
4904 // |---------------->| |
4906 // | RESTSubResp | |
4907 // |<----------------| |
4908 // | RESTSubDelReq | |
4909 // |---------------->| |
4910 // | RESTSubDelResp | |
4912 // |<----------------| |
4915 //-----------------------------------------------------------------------------
4916 func TestRESTSubReqAsn1EncodeFail(t *testing.T) {
4917 CaseBegin("TestRESTSubReqAsn1EncodeFail")
4919 xapp.Logger.Debug("Xapp-frame, v0.8.1 sufficient REST API validation")
4923 //-----------------------------------------------------------------------------
4924 // TestRESTSubReqInsertAndSubDelOk
4927 // +-------+ +---------+ +---------+
4928 // | xapp | | submgr | | e2term |
4929 // +-------+ +---------+ +---------+
4932 // |---------------->| |
4934 // | RESTSubResp | |
4935 // |<----------------| |
4938 // | |------------->|
4941 // | |<-------------|
4943 // |<----------------| |
4946 // | RESTSubDelReq | |
4947 // |---------------->| |
4950 // | |------------->|
4953 // | |<-------------|
4955 // | RESTSubDelResp| |
4956 // |<----------------| |
4958 //-----------------------------------------------------------------------------
4959 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
4960 CaseBegin("TestRESTInsertSubReqAndSubDelOk")
4962 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4963 Counter{cRestSubReqFromXapp, 1},
4964 Counter{cRestSubRespToXapp, 1},
4965 Counter{cSubReqToE2, 1},
4966 Counter{cSubRespFromE2, 1},
4967 Counter{cRestSubNotifToXapp, 1},
4968 Counter{cRestSubDelReqFromXapp, 1},
4969 Counter{cSubDelReqToE2, 1},
4970 Counter{cSubDelRespFromE2, 1},
4971 Counter{cRestSubDelRespToXapp, 1},
4974 const subReqCount int = 1
4976 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4977 params.SetSubActionTypes("insert")
4980 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4983 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4985 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4986 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4988 // Wait that subs is cleaned
4989 waitSubsCleanup(t, e2SubsId, 10)
4990 mainCtrl.VerifyCounterValues(t)
4991 mainCtrl.VerifyAllClean(t)
4994 //-----------------------------------------------------------------------------
4995 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
4998 // +-------+ +---------+ +---------+
4999 // | xapp | | submgr | | e2term |
5000 // +-------+ +---------+ +---------+
5003 // |------------->| |
5005 // | RESTSubResp | |
5006 // |<-------------| |
5008 // | |------------->|
5013 // | Submgr restart |
5017 // | |------------->|
5020 // | |<-------------|
5024 // |<-------------| |
5026 // | RESTSubDelReq| |
5027 // |------------->| |
5029 // |RESTSubDelResp| |
5030 // |<-------------| |
5032 //-----------------------------------------------------------------------------
5033 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
5034 CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle")
5036 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5037 Counter{cRestSubReqFromXapp, 1},
5038 Counter{cRestSubRespToXapp, 1},
5039 Counter{cSubReqToE2, 1},
5040 Counter{cSubDelReqFromXapp, 1},
5041 Counter{cSubDelReqToE2, 1},
5042 Counter{cSubDelRespFromE2, 1},
5043 Counter{cRestSubDelReqFromXapp, 1},
5044 Counter{cRestSubDelRespToXapp, 1},
5047 const subReqCount int = 1
5049 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5052 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
5053 restSubId := xappConn1.SendRESTSubsReq(t, params)
5054 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5056 e2termConn1.RecvSubsReq(t)
5058 mainCtrl.SetResetTestFlag(t, false)
5060 mainCtrl.SimulateRestart(t)
5061 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5063 // Deleletion of uncompleted subscription
5064 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5065 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5068 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5070 xappConn1.TestMsgChanEmpty(t)
5071 e2termConn1.TestMsgChanEmpty(t)
5072 mainCtrl.wait_registry_empty(t, 10)
5074 mainCtrl.VerifyCounterValues(t)
5075 mainCtrl.VerifyAllClean(t)
5078 //-----------------------------------------------------------------------------
5079 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
5082 // +-------+ +---------+ +---------+
5083 // | xapp | | submgr | | e2term |
5084 // +-------+ +---------+ +---------+
5087 // |---------------->| |
5089 // | RESTSubResp | |
5090 // |<----------------| |
5092 // | |------------->|
5095 // | |<-------------|
5098 // |<----------------| |
5101 // | Submgr restart |
5103 // | RESTSubDelReq | |
5104 // |---------------->| |
5107 // | |------------->|
5110 // | |<-------------|
5112 // | RESTSubDelResp | |
5113 // |<----------------| |
5115 //-----------------------------------------------------------------------------
5117 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
5118 CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle")
5120 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5121 Counter{cRestSubReqFromXapp, 1},
5122 Counter{cRestSubRespToXapp, 1},
5123 Counter{cSubReqToE2, 1},
5124 Counter{cSubRespFromE2, 1},
5125 Counter{cRestSubNotifToXapp, 1},
5126 Counter{cRestSubDelReqFromXapp, 1},
5127 Counter{cSubDelReqToE2, 1},
5128 Counter{cSubDelRespFromE2, 1},
5129 Counter{cRestSubDelRespToXapp, 1},
5132 // Create subscription
5133 var params *teststube2ap.RESTSubsReqParams = nil
5134 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5135 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5137 // Check subscription
5138 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5140 mainCtrl.SimulateRestart(t)
5141 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5143 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5144 // That needs to be completed before successful subscription query is possible
5145 <-time.After(time.Second * 1)
5147 // Check subscription
5148 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5150 // Delete subscription
5151 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
5153 //Wait that subs is cleaned
5154 waitSubsCleanup(t, e2SubsId, 10)
5156 mainCtrl.VerifyCounterValues(t)
5157 mainCtrl.VerifyAllClean(t)
5160 //-----------------------------------------------------------------------------
5161 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
5164 // +-------+ +-------+ +---------+ +---------+
5165 // | xapp2 | | xapp1 | | submgr | | e2term |
5166 // +-------+ +-------+ +---------+ +---------+
5168 // | | RESTSubReq1 | |
5169 // | |---------------->| |
5171 // | | RESTSubResp1 | |
5172 // | |<----------------| |
5175 // | | |------------->|
5177 // | | |<-------------|
5178 // | | RESTNotif1 | |
5179 // | |<----------------| |
5181 // | RESTSubReq2 | |
5182 // |------------------------------>| |
5184 // | RESTSubResp2 | |
5185 // |<------------------------------| |
5187 // | | RESTNotif2 | |
5188 // |<------------------------------| |
5190 // | | Submgr restart |
5192 // | | RESTSubDelReq1 | |
5193 // | |---------------->| |
5195 // | | RESTSubDelResp1 | |
5196 // | |<----------------| |
5198 // | | Submgr restart |
5200 // | RESTSubDelReq2 | |
5201 // |------------------------------>| |
5203 // | RESTSubDelResp2 | |
5204 // |<------------------------------| |
5206 // | | | SubDelReq2 |
5207 // | | |------------->|
5209 // | | | SubDelResp2 |
5210 // | | |<-------------|
5213 //-----------------------------------------------------------------------------
5214 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
5215 CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
5217 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5218 Counter{cRestSubReqFromXapp, 2},
5219 Counter{cRestSubRespToXapp, 2},
5220 Counter{cSubReqToE2, 1},
5221 Counter{cSubRespFromE2, 1},
5222 Counter{cRestSubNotifToXapp, 2},
5223 Counter{cMergedSubscriptions, 1},
5224 Counter{cUnmergedSubscriptions, 1},
5225 Counter{cRestSubDelReqFromXapp, 2},
5226 Counter{cSubDelReqToE2, 1},
5227 Counter{cSubDelRespFromE2, 1},
5228 Counter{cRestSubDelRespToXapp, 2},
5231 // Create subscription 1
5232 var params *teststube2ap.RESTSubsReqParams = nil
5233 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5234 xapp.Logger.Debug("Send REST subscriber request for subscriber 1 : %v", restSubId1)
5236 // Create subscription 2 with same action
5237 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5238 params.SetMeid("RAN_NAME_1")
5239 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
5240 xappConn2.ExpectAnyNotification(t)
5241 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5242 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5243 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
5244 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
5246 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
5248 mainCtrl.SimulateRestart(t)
5249 xapp.Logger.Debug("mainCtrl.SimulateRestart done 1")
5251 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5252 // That needs to be completed before successful subscription delete is possible
5253 <-time.After(time.Second * 1)
5255 // Delete subscription 1, and wait until it has removed the first endpoint
5256 subepcnt := mainCtrl.get_subs_entrypoint_cnt(t, e2SubsId1)
5257 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5258 mainCtrl.wait_subs_entrypoint_cnt_change(t, e2SubsId1, subepcnt, 10)
5260 // Above wait does not work correctly anymore as this delay makes this test case work
5261 //<-time.After(time.Second * 1)
5263 mainCtrl.SimulateRestart(t)
5264 xapp.Logger.Debug("mainCtrl.SimulateRestart done 2")
5266 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5267 // That needs to be completed before successful subscription query is possible
5268 <-time.After(time.Second * 1)
5270 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
5272 // Delete subscription 2
5273 deleteXapp2Subscription(t, &restSubId2)
5275 //Wait that subs is cleaned
5276 waitSubsCleanup(t, e2SubsId2, 10)
5278 mainCtrl.VerifyCounterValues(t)
5279 mainCtrl.VerifyAllClean(t)
5282 //-----------------------------------------------------------------------------
5283 // TestRESTReportSubReqAndSubDelOk
5286 // +-------+ +---------+ +---------+
5287 // | xapp | | submgr | | e2term |
5288 // +-------+ +---------+ +---------+
5291 // |---------------->| |
5293 // | RESTSubResp | |
5294 // |<----------------| |
5297 // | |------------->|
5300 // | |<-------------|
5302 // |<----------------| |
5304 // | |------------->|
5307 // | |<-------------|
5309 // |<----------------| |
5313 // | RESTSubDelReq | |
5314 // |---------------->| |
5317 // | |------------->|
5320 // | |<-------------|
5322 // | RESTSubDelResp| |
5323 // |<----------------| |
5325 //-----------------------------------------------------------------------------
5327 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
5328 CaseBegin("TestRESTReportSubReqAndSubDelOk")
5329 const subReqCount int = 1
5331 RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
5334 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5335 xapp.Logger.Debug("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
5338 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5339 restSubId := xappConn1.SendRESTSubsReq(t, params)
5341 var e2SubsId []uint32
5342 for i := 0; i < subReqCount; i++ {
5343 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5344 xappConn1.ExpectRESTNotification(t, restSubId)
5346 e2termConn1.SendSubsResp(t, crereq, cremsg)
5347 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5348 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5349 e2SubsId = append(e2SubsId, instanceId)
5350 resp, _ := xapp.Subscription.QuerySubscriptions()
5351 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
5352 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
5353 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
5358 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5360 for i := 0; i < subReqCount; i++ {
5361 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5362 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5365 // Wait that subs is cleaned
5366 for i := 0; i < subReqCount; i++ {
5367 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5370 xappConn1.TestMsgChanEmpty(t)
5371 e2termConn1.TestMsgChanEmpty(t)
5372 mainCtrl.wait_registry_empty(t, 10)
5373 mainCtrl.VerifyAllClean(t)
5377 func TestRESTPolicySubReqAndSubDelOk(t *testing.T) { was in comments already
5378 CaseBegin("TestRESTPolicySubReqAndSubDelOk")
5382 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5386 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5389 func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5390 xapp.Logger.Debug("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
5393 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5394 restSubId := xappConn1.SendRESTSubsReq(t, params)
5396 var e2SubsId []uint32
5397 for i := 0; i < subReqCount; i++ {
5398 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5399 xappConn1.ExpectRESTNotification(t, restSubId)
5400 e2termConn1.SendSubsResp(t, crereq, cremsg)
5401 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5402 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5403 e2SubsId = append(e2SubsId, instanceId)
5407 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5409 for i := 0; i < subReqCount; i++ {
5410 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5411 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5414 // Wait that subs is cleaned
5415 for i := 0; i < subReqCount; i++ {
5416 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5418 xappConn1.TestMsgChanEmpty(t)
5419 e2termConn1.TestMsgChanEmpty(t)
5420 mainCtrl.wait_registry_empty(t, 10)
5421 mainCtrl.VerifyAllClean(t)
5424 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
5426 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5427 Counter{cRestSubReqFromXapp, 1},
5428 Counter{cRestSubRespToXapp, 1},
5429 Counter{cSubReqToE2, 2},
5430 Counter{cSubRespFromE2, 2},
5431 Counter{cRestSubNotifToXapp, 2},
5432 Counter{cRestSubDelReqFromXapp, 1},
5433 Counter{cSubDelReqToE2, 2},
5434 Counter{cSubDelRespFromE2, 2},
5435 Counter{cRestSubDelRespToXapp, 1},
5438 const subReqCount int = 2
5441 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5442 restSubId := xappConn1.SendRESTSubsReq(t, params)
5443 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5445 assert.Equal(t, len(e2SubsIds), 2)
5448 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5449 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5451 xappConn1.TestMsgChanEmpty(t)
5452 e2termConn1.TestMsgChanEmpty(t)
5453 mainCtrl.wait_registry_empty(t, 10)
5455 mainCtrl.VerifyCounterValues(t)
5456 mainCtrl.VerifyAllClean(t)
5458 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
5460 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5461 Counter{cRestSubReqFromXapp, 1},
5462 Counter{cRestSubRespToXapp, 1},
5463 Counter{cSubReqToE2, 19},
5464 Counter{cSubRespFromE2, 19},
5465 Counter{cRestSubNotifToXapp, 19},
5466 Counter{cRestSubDelReqFromXapp, 1},
5467 Counter{cSubDelReqToE2, 19},
5468 Counter{cSubDelRespFromE2, 19},
5469 Counter{cRestSubDelRespToXapp, 1},
5472 const subReqCount int = 19
5474 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5475 restSubId := xappConn1.SendRESTSubsReq(t, params)
5476 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5478 assert.Equal(t, len(e2SubsIds), 19)
5480 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5481 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5483 xappConn1.TestMsgChanEmpty(t)
5484 e2termConn1.TestMsgChanEmpty(t)
5485 mainCtrl.wait_registry_empty(t, 10)
5487 mainCtrl.VerifyCounterValues(t)
5488 mainCtrl.VerifyAllClean(t)
5491 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
5495 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5496 Counter{cRestSubReqFromXapp, 1},
5497 Counter{cRestSubRespToXapp, 1},
5498 Counter{cSubReqToE2, uint64(subReqCount)},
5499 Counter{cSubRespFromE2, uint64(subReqCount)},
5500 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5501 Counter{cRestSubDelReqFromXapp, 1},
5502 Counter{cSubDelReqToE2, uint64(subReqCount)},
5503 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5504 Counter{cRestSubDelRespToXapp, 1},
5508 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5509 restSubId := xappConn1.SendRESTSubsReq(t, params)
5510 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5512 assert.Equal(t, len(e2SubsIds), subReqCount)
5515 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5516 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5518 xappConn1.TestMsgChanEmpty(t)
5519 e2termConn1.TestMsgChanEmpty(t)
5520 mainCtrl.wait_registry_empty(t, 10)
5522 mainCtrl.VerifyCounterValues(t)
5523 mainCtrl.VerifyAllClean(t)
5526 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
5530 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5531 Counter{cRestSubReqFromXapp, 1},
5532 Counter{cRestSubRespToXapp, 1},
5533 Counter{cSubReqToE2, uint64(subReqCount)},
5534 Counter{cSubRespFromE2, uint64(subReqCount)},
5535 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5536 Counter{cRestSubDelReqFromXapp, 1},
5537 Counter{cSubDelReqToE2, uint64(subReqCount)},
5538 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5539 Counter{cRestSubDelRespToXapp, 1},
5543 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5544 restSubId := xappConn1.SendRESTSubsReq(t, params)
5545 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5547 assert.Equal(t, len(e2SubsIds), subReqCount)
5550 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5551 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5553 xappConn1.TestMsgChanEmpty(t)
5554 e2termConn1.TestMsgChanEmpty(t)
5555 mainCtrl.wait_registry_empty(t, 10)
5557 mainCtrl.VerifyCounterValues(t)
5558 mainCtrl.VerifyAllClean(t)
5561 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
5565 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5566 Counter{cRestSubReqFromXapp, 1},
5567 Counter{cRestSubRespToXapp, 1},
5568 Counter{cSubReqToE2, uint64(subReqCount)},
5569 Counter{cSubRespFromE2, uint64(subReqCount)},
5570 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5571 Counter{cRestSubDelReqFromXapp, 1},
5572 Counter{cSubDelReqToE2, uint64(subReqCount)},
5573 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5574 Counter{cRestSubDelRespToXapp, 1},
5578 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5579 restSubId := xappConn1.SendRESTSubsReq(t, params)
5580 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5582 assert.Equal(t, len(e2SubsIds), subReqCount)
5585 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5586 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5588 xappConn1.TestMsgChanEmpty(t)
5589 e2termConn1.TestMsgChanEmpty(t)
5590 mainCtrl.wait_registry_empty(t, 10)
5592 mainCtrl.VerifyCounterValues(t)
5593 mainCtrl.VerifyAllClean(t)
5596 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
5597 CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
5599 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5600 Counter{cRestSubReqFromXapp, 2},
5601 Counter{cRestSubRespToXapp, 2},
5602 Counter{cSubReqToE2, 2},
5603 Counter{cSubRespFromE2, 2},
5604 Counter{cRestSubNotifToXapp, 2},
5605 Counter{cRestSubDelReqFromXapp, 2},
5606 Counter{cSubDelReqToE2, 2},
5607 Counter{cSubDelRespFromE2, 2},
5608 Counter{cRestSubDelRespToXapp, 2},
5612 var params *teststube2ap.RESTSubsReqParams = nil
5615 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5616 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5618 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5621 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5622 params.SetMeid("RAN_NAME_1")
5623 eventTriggerDefinition := []int64{1234, 1}
5624 params.SetSubEventTriggerDefinition(eventTriggerDefinition)
5626 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5627 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5628 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5629 xappConn2.ExpectRESTNotification(t, restSubId2)
5630 e2termConn1.SendSubsResp(t, crereq, cremsg)
5631 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5633 deleteXapp1Subscription(t, &restSubId1)
5634 deleteXapp2Subscription(t, &restSubId2)
5636 waitSubsCleanup(t, e2SubsId1, 10)
5637 waitSubsCleanup(t, e2SubsId2, 10)
5639 mainCtrl.VerifyCounterValues(t)
5640 mainCtrl.VerifyAllClean(t)
5643 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
5644 CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
5646 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5647 Counter{cRestSubReqFromXapp, 2},
5648 Counter{cRestSubRespToXapp, 2},
5649 Counter{cSubReqToE2, 2},
5650 Counter{cSubRespFromE2, 2},
5651 Counter{cRestSubNotifToXapp, 2},
5652 Counter{cRestSubDelReqFromXapp, 2},
5653 Counter{cSubDelReqToE2, 2},
5654 Counter{cSubDelRespFromE2, 2},
5655 Counter{cRestSubDelRespToXapp, 2},
5659 var params *teststube2ap.RESTSubsReqParams = nil
5662 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5663 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5665 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5668 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5669 params.SetMeid("RAN_NAME_1")
5671 actionId := int64(1)
5672 actionType := "report"
5673 actionDefinition := []int64{5678, 1}
5674 subsequestActionType := "continue"
5675 timeToWait := "w10ms"
5676 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
5678 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5679 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5680 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5681 xappConn2.ExpectRESTNotification(t, restSubId2)
5682 e2termConn1.SendSubsResp(t, crereq, cremsg)
5683 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5685 deleteXapp1Subscription(t, &restSubId1)
5686 deleteXapp2Subscription(t, &restSubId2)
5688 waitSubsCleanup(t, e2SubsId1, 10)
5689 waitSubsCleanup(t, e2SubsId2, 10)
5691 mainCtrl.VerifyCounterValues(t)
5692 mainCtrl.VerifyAllClean(t)
5695 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
5696 CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
5698 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5699 Counter{cRestSubReqFromXapp, 2},
5700 Counter{cRestSubRespToXapp, 2},
5701 Counter{cSubReqToE2, 2},
5702 Counter{cSubRespFromE2, 2},
5703 Counter{cRestSubNotifToXapp, 2},
5704 Counter{cRestSubDelReqFromXapp, 2},
5705 Counter{cSubDelReqToE2, 2},
5706 Counter{cSubDelRespFromE2, 2},
5707 Counter{cRestSubDelRespToXapp, 2},
5711 var params *teststube2ap.RESTSubsReqParams = nil
5714 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5715 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5717 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5720 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5721 params.SetMeid("RAN_NAME_1")
5722 params.SetSubActionIDs(int64(2))
5724 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5725 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5726 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5727 xappConn2.ExpectRESTNotification(t, restSubId2)
5728 e2termConn1.SendSubsResp(t, crereq, cremsg)
5729 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5731 deleteXapp1Subscription(t, &restSubId1)
5732 deleteXapp2Subscription(t, &restSubId2)
5734 waitSubsCleanup(t, e2SubsId1, 10)
5735 waitSubsCleanup(t, e2SubsId2, 10)
5737 mainCtrl.VerifyCounterValues(t)
5738 mainCtrl.VerifyAllClean(t)
5741 func TestRESTSubReqDiffActionType(t *testing.T) {
5742 CaseBegin("TestRESTSubReqDiffActionType")
5744 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5745 Counter{cRestSubReqFromXapp, 2},
5746 Counter{cRestSubRespToXapp, 2},
5747 Counter{cSubReqToE2, 2},
5748 Counter{cSubRespFromE2, 2},
5749 Counter{cRestSubNotifToXapp, 2},
5750 Counter{cRestSubDelReqFromXapp, 2},
5751 Counter{cSubDelReqToE2, 2},
5752 Counter{cSubDelRespFromE2, 2},
5753 Counter{cRestSubDelRespToXapp, 2},
5756 const e2Timeout int64 = 2
5757 const e2RetryCount int64 = 2
5758 const routingNeeded bool = true
5761 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5762 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5765 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5766 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5768 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5771 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5772 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5773 params.SetMeid("RAN_NAME_1")
5775 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5776 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5777 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5778 xappConn2.ExpectRESTNotification(t, restSubId2)
5779 e2termConn1.SendSubsResp(t, crereq, cremsg)
5780 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5782 deleteXapp1Subscription(t, &restSubId1)
5783 deleteXapp2Subscription(t, &restSubId2)
5785 waitSubsCleanup(t, e2SubsId1, 10)
5786 waitSubsCleanup(t, e2SubsId2, 10)
5788 mainCtrl.VerifyCounterValues(t)
5789 mainCtrl.VerifyAllClean(t)
5792 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
5793 CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
5795 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5796 Counter{cRestSubReqFromXapp, 2},
5797 Counter{cRestSubRespToXapp, 2},
5798 Counter{cSubReqToE2, 2},
5799 Counter{cSubRespFromE2, 2},
5800 Counter{cRestSubNotifToXapp, 2},
5801 Counter{cRestSubDelReqFromXapp, 2},
5802 Counter{cSubDelReqToE2, 2},
5803 Counter{cSubDelRespFromE2, 2},
5804 Counter{cRestSubDelRespToXapp, 2},
5807 const e2Timeout int64 = 2
5808 const e2RetryCount int64 = 2
5809 const routingNeeded bool = true
5812 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5813 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5816 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5817 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5819 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5822 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
5823 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5824 params.SetMeid("RAN_NAME_1")
5826 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5827 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5828 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5829 xappConn2.ExpectRESTNotification(t, restSubId2)
5830 e2termConn1.SendSubsResp(t, crereq, cremsg)
5831 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5833 deleteXapp1Subscription(t, &restSubId1)
5834 deleteXapp2Subscription(t, &restSubId2)
5836 waitSubsCleanup(t, e2SubsId1, 10)
5837 waitSubsCleanup(t, e2SubsId2, 10)
5839 mainCtrl.VerifyCounterValues(t)
5840 mainCtrl.VerifyAllClean(t)
5843 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
5844 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
5846 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5847 Counter{cRestSubReqFromXapp, 2},
5848 Counter{cRestSubRespToXapp, 2},
5849 Counter{cSubReqToE2, 2},
5850 Counter{cSubRespFromE2, 2},
5851 Counter{cRestSubNotifToXapp, 2},
5852 Counter{cRestSubDelReqFromXapp, 2},
5853 Counter{cSubDelReqToE2, 2},
5854 Counter{cSubDelRespFromE2, 2},
5855 Counter{cRestSubDelRespToXapp, 2},
5859 var params *teststube2ap.RESTSubsReqParams = nil
5862 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5863 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5865 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5868 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5869 params.SetMeid("RAN_NAME_1")
5870 actionDefinition := []int64{5678, 1}
5871 params.SetSubActionDefinition(actionDefinition)
5873 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5874 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5875 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5876 xappConn2.ExpectRESTNotification(t, restSubId2)
5877 e2termConn1.SendSubsResp(t, crereq, cremsg)
5878 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5880 deleteXapp1Subscription(t, &restSubId1)
5881 deleteXapp2Subscription(t, &restSubId2)
5883 waitSubsCleanup(t, e2SubsId1, 10)
5884 waitSubsCleanup(t, e2SubsId2, 10)
5886 mainCtrl.VerifyCounterValues(t)
5887 mainCtrl.VerifyAllClean(t)
5890 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
5891 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
5893 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5894 Counter{cRestSubReqFromXapp, 2},
5895 Counter{cRestSubRespToXapp, 2},
5896 Counter{cSubReqToE2, 2},
5897 Counter{cSubRespFromE2, 2},
5898 Counter{cRestSubNotifToXapp, 2},
5899 Counter{cRestSubDelReqFromXapp, 2},
5900 Counter{cSubDelReqToE2, 2},
5901 Counter{cSubDelRespFromE2, 2},
5902 Counter{cRestSubDelRespToXapp, 2},
5906 var params *teststube2ap.RESTSubsReqParams = nil
5909 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5910 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5912 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5915 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5916 params.SetMeid("RAN_NAME_1")
5917 actionDefinition := []int64{56782}
5918 params.SetSubActionDefinition(actionDefinition)
5920 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5921 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5922 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5923 xappConn2.ExpectRESTNotification(t, restSubId2)
5924 e2termConn1.SendSubsResp(t, crereq, cremsg)
5925 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5927 deleteXapp1Subscription(t, &restSubId1)
5928 deleteXapp2Subscription(t, &restSubId2)
5930 waitSubsCleanup(t, e2SubsId1, 10)
5931 waitSubsCleanup(t, e2SubsId2, 10)
5933 mainCtrl.VerifyCounterValues(t)
5934 mainCtrl.VerifyAllClean(t)
5937 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
5938 CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
5940 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5941 Counter{cRestSubReqFromXapp, 2},
5942 Counter{cRestSubRespToXapp, 2},
5943 Counter{cSubReqToE2, 2},
5944 Counter{cSubRespFromE2, 2},
5945 Counter{cRestSubNotifToXapp, 2},
5946 Counter{cRestSubDelReqFromXapp, 2},
5947 Counter{cSubDelReqToE2, 2},
5948 Counter{cSubDelRespFromE2, 2},
5949 Counter{cRestSubDelRespToXapp, 2},
5953 var params *teststube2ap.RESTSubsReqParams = nil
5956 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5957 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5959 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5962 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5963 params.SetMeid("RAN_NAME_1")
5964 params.SetTimeToWait("w200ms")
5965 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5966 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5967 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5968 xappConn2.ExpectRESTNotification(t, restSubId2)
5969 e2termConn1.SendSubsResp(t, crereq, cremsg)
5970 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5972 deleteXapp1Subscription(t, &restSubId1)
5973 deleteXapp2Subscription(t, &restSubId2)
5975 waitSubsCleanup(t, e2SubsId1, 10)
5976 waitSubsCleanup(t, e2SubsId2, 10)
5978 mainCtrl.VerifyCounterValues(t)
5979 mainCtrl.VerifyAllClean(t)
5982 //-----------------------------------------------------------------------------
5983 // TestRESTUnpackSubscriptionResponseDecodeFail
5986 // +-------+ +---------+ +---------+
5987 // | xapp | | submgr | | e2term |
5988 // +-------+ +---------+ +---------+
5991 // |---------------->| |
5993 // | RESTSubResp | |
5994 // |<----------------| |
5997 // | |------------->|
5999 // | | SubResp | ASN.1 decode fails
6000 // | |<-------------|
6003 // | |------------->|
6005 // | | SubFail | Duplicated action
6006 // | |<-------------|
6007 // | RESTNotif (fail)| |
6008 // |<----------------| |
6011 //-----------------------------------------------------------------------------
6013 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
6014 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
6015 const subReqCount int = 1
6018 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6019 restSubId := xappConn1.SendRESTSubsReq(t, params)
6021 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6022 // Decode of this response fails which will result resending original request
6023 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
6025 _, cremsg = e2termConn1.RecvSubsReq(t)
6027 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6029 // Subscription already created in E2 Node.
6030 fparams := &teststube2ap.E2StubSubsFailParams{}
6032 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6033 e2termConn1.SendSubsFail(t, fparams, cremsg)
6035 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6036 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6038 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6040 // Wait that subs is cleaned
6041 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6043 xappConn1.TestMsgChanEmpty(t)
6044 e2termConn1.TestMsgChanEmpty(t)
6045 mainCtrl.wait_registry_empty(t, 10)
6046 mainCtrl.VerifyAllClean(t)
6049 //-----------------------------------------------------------------------------
6050 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
6053 // +-------+ +---------+ +---------+
6054 // | xapp | | submgr | | e2term |
6055 // +-------+ +---------+ +---------+
6058 // |---------------->| |
6060 // | RESTSubResp | |
6061 // |<----------------| |
6064 // | |------------->|
6066 // | | SubResp | Unknown instanceId
6067 // | |<-------------|
6070 // | |------------->|
6072 // | | SubFail | Duplicated action
6073 // | |<-------------|
6074 // | RESTNotif (fail)| |
6075 // |<----------------| |
6077 // | |------------->|
6080 // | |<-------------|
6082 //-----------------------------------------------------------------------------
6084 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
6085 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
6086 const subReqCount int = 1
6089 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6090 restSubId := xappConn1.SendRESTSubsReq(t, params)
6092 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6094 // Unknown instanceId in this response which will result resending original request
6095 orgInstanceId := crereq.RequestId.InstanceId
6096 crereq.RequestId.InstanceId = 0
6097 e2termConn1.SendSubsResp(t, crereq, cremsg)
6099 _, cremsg = e2termConn1.RecvSubsReq(t)
6101 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6103 // Subscription already created in E2 Node.
6104 fparams := &teststube2ap.E2StubSubsFailParams{}
6106 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6107 e2termConn1.SendSubsFail(t, fparams, cremsg)
6109 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6110 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6112 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6113 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6115 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6117 // Wait that subs is cleaned
6118 mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
6120 xappConn1.TestMsgChanEmpty(t)
6121 e2termConn1.TestMsgChanEmpty(t)
6122 mainCtrl.wait_registry_empty(t, 10)
6123 mainCtrl.VerifyAllClean(t)
6126 //-----------------------------------------------------------------------------
6127 // TestRESTUnpackSubscriptionResponseNoTransaction
6130 // +-------+ +---------+ +---------+
6131 // | xapp | | submgr | | e2term |
6132 // +-------+ +---------+ +---------+
6135 // |---------------->| |
6137 // | RESTSubResp | |
6138 // |<----------------| |
6141 // | |------------->|
6143 // | | SubResp | No transaction for the response
6144 // | |<-------------|
6147 // | |------------->|
6149 // | | SubFail | Duplicated action
6150 // | |<-------------|
6151 // | RESTNotif (fail)| |
6152 // |<----------------| |
6154 // | |------------->|
6157 // | |<-------------|
6160 // | |------------->|
6163 // | |<-------------|
6165 //-----------------------------------------------------------------------------
6166 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
6167 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
6168 const subReqCount int = 1
6171 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6172 restSubId := xappConn1.SendRESTSubsReq(t, params)
6174 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6176 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6177 // No transaction exist for this response which will result resending original request
6178 e2termConn1.SendSubsResp(t, crereq, cremsg)
6180 _, cremsg = e2termConn1.RecvSubsReq(t)
6182 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6184 // Subscription already created in E2 Node.
6185 fparams := &teststube2ap.E2StubSubsFailParams{}
6187 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6188 e2termConn1.SendSubsFail(t, fparams, cremsg)
6190 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6191 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6193 // Resending happens because there no transaction
6194 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6195 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6197 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6198 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6200 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6202 // Wait that subs is cleaned
6203 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6205 xappConn1.TestMsgChanEmpty(t)
6206 e2termConn1.TestMsgChanEmpty(t)
6207 mainCtrl.wait_registry_empty(t, 10)
6208 mainCtrl.VerifyAllClean(t)
6211 //-----------------------------------------------------------------------------
6212 // TestRESTUnpackSubscriptionFailureDecodeFail
6215 // +-------+ +---------+ +---------+
6216 // | xapp | | submgr | | e2term |
6217 // +-------+ +---------+ +---------+
6220 // |---------------->| |
6222 // | RESTSubResp | |
6223 // |<----------------| |
6226 // | |------------->|
6228 // | | SubFail | ASN.1 decode fails
6229 // | |<-------------|
6232 // | |------------->|
6234 // | | SubFail | Duplicated action
6235 // | |<-------------|
6236 // | RESTNotif (fail)| |
6237 // |<----------------| |
6240 //-----------------------------------------------------------------------------
6241 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
6242 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
6243 const subReqCount int = 1
6246 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6247 restSubId := xappConn1.SendRESTSubsReq(t, params)
6249 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6251 // Decode of this response fails which will result resending original request
6252 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
6254 _, cremsg = e2termConn1.RecvSubsReq(t)
6256 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6258 // Subscription already created in E2 Node.
6259 fparams := &teststube2ap.E2StubSubsFailParams{}
6261 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6262 e2termConn1.SendSubsFail(t, fparams, cremsg)
6264 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6265 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6267 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6269 // Wait that subs is cleaned
6270 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6272 xappConn1.TestMsgChanEmpty(t)
6273 e2termConn1.TestMsgChanEmpty(t)
6274 mainCtrl.wait_registry_empty(t, 10)
6275 mainCtrl.VerifyAllClean(t)
6278 //-----------------------------------------------------------------------------
6279 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
6282 // +-------+ +---------+ +---------+
6283 // | xapp | | submgr | | e2term |
6284 // +-------+ +---------+ +---------+
6287 // |---------------->| |
6289 // | RESTSubResp | |
6290 // |<----------------| |
6293 // | |------------->|
6295 // | | SubFail | Unknown instanceId
6296 // | |<-------------|
6299 // | |------------->|
6301 // | | SubFail | Duplicated action
6302 // | |<-------------|
6303 // | RESTNotif (fail)| |
6304 // |<----------------| |
6306 // | |------------->|
6309 // | |<-------------|
6311 //-----------------------------------------------------------------------------
6312 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
6313 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
6314 const subReqCount int = 1
6317 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6318 restSubId := xappConn1.SendRESTSubsReq(t, params)
6320 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6322 // Unknown instanceId in this response which will result resending original request
6323 fparams := &teststube2ap.E2StubSubsFailParams{}
6325 fparams.Fail.RequestId.InstanceId = 0
6326 e2termConn1.SendSubsFail(t, fparams, cremsg)
6328 _, cremsg = e2termConn1.RecvSubsReq(t)
6330 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6332 // Subscription already created in E2 Node.
6333 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6334 e2termConn1.SendSubsFail(t, fparams, cremsg)
6336 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6337 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6339 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6340 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6342 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6344 // Wait that subs is cleaned
6345 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6347 xappConn1.TestMsgChanEmpty(t)
6348 e2termConn1.TestMsgChanEmpty(t)
6349 mainCtrl.wait_registry_empty(t, 10)
6350 mainCtrl.VerifyAllClean(t)
6353 //-----------------------------------------------------------------------------
6354 // TestRESTUnpackSubscriptionFailureNoTransaction
6357 // +-------+ +---------+ +---------+
6358 // | xapp | | submgr | | e2term |
6359 // +-------+ +---------+ +---------+
6362 // |---------------->| |
6364 // | RESTSubResp | |
6365 // |<----------------| |
6368 // | |------------->|
6370 // | | SubFail | No transaction for the response
6371 // | |<-------------|
6374 // | |------------->|
6376 // | | SubFail | Duplicated action
6377 // | |<-------------|
6378 // | RESTNotif (fail)| |
6379 // |<----------------| |
6381 // | |------------->|
6384 // | |<-------------|
6386 //-----------------------------------------------------------------------------
6387 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
6388 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
6389 const subReqCount int = 1
6392 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6393 restSubId := xappConn1.SendRESTSubsReq(t, params)
6395 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6397 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6399 // No transaction exist for this response which will result resending original request
6400 fparams := &teststube2ap.E2StubSubsFailParams{}
6402 e2termConn1.SendSubsFail(t, fparams, cremsg)
6404 _, cremsg = e2termConn1.RecvSubsReq(t)
6406 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6408 // Subscription already created in E2 Node.
6409 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6410 e2termConn1.SendSubsFail(t, fparams, cremsg)
6412 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6413 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6415 // Resending happens because there no transaction
6416 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6417 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6419 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6420 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6422 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6424 // Wait that subs is cleaned
6425 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6427 xappConn1.TestMsgChanEmpty(t)
6428 e2termConn1.TestMsgChanEmpty(t)
6429 mainCtrl.wait_registry_empty(t, 10)
6430 mainCtrl.VerifyAllClean(t)
6433 //-----------------------------------------------------------------------------
6434 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
6437 // +-------+ +---------+ +---------+
6438 // | xapp | | submgr | | e2term |
6439 // +-------+ +---------+ +---------+
6441 // | [SUBS CREATE] |
6444 // | RESTSubDelReq | |
6445 // |---------------->| |
6447 // | RESTSubDelResp | |
6448 // |<----------------| |
6451 // | |------------->|
6453 // | | SubDelResp | ASN.1 decode fails
6454 // | |<-------------|
6457 // | |------------->|
6459 // | | SubDelFail | Subscription does exist any more
6460 // | |<-------------|
6463 //-----------------------------------------------------------------------------
6464 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
6465 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail")
6468 var params *teststube2ap.RESTSubsReqParams = nil
6469 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6472 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6474 // E2t: Receive 1st SubsDelReq
6475 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6477 // Decode of this response fails which will result resending original request
6478 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_REQ)
6480 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6481 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6483 // Subscription does not exist in in E2 Node.
6484 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6486 // Wait that subs is cleaned
6487 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6489 xappConn1.TestMsgChanEmpty(t)
6490 e2termConn1.TestMsgChanEmpty(t)
6491 mainCtrl.wait_registry_empty(t, 10)
6492 mainCtrl.VerifyAllClean(t)
6495 //-----------------------------------------------------------------------------
6496 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
6499 // +-------+ +---------+ +---------+
6500 // | xapp | | submgr | | e2term |
6501 // +-------+ +---------+ +---------+
6503 // | [SUBS CREATE] |
6506 // | RESTSubDelReq | |
6507 // |---------------->| |
6509 // | RESTSubDelResp | |
6510 // |<----------------| |
6513 // | |------------->|
6515 // | | SubDelResp | Unknown instanceId
6516 // | |<-------------|
6519 // | |------------->|
6521 // | | SubDelFail | Subscription does exist any more
6522 // | |<-------------|
6524 //-----------------------------------------------------------------------------
6525 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
6526 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId")
6529 var params *teststube2ap.RESTSubsReqParams = nil
6530 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6533 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6535 // E2t: Receive 1st SubsDelReq
6536 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6538 // Unknown instanceId in this response which will result resending original request
6539 delreq.RequestId.InstanceId = 0
6540 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6542 // E2t: Receive 2nd SubsDelReq
6543 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6545 // Subscription does not exist in in E2 Node.
6546 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6548 // Wait that subs is cleaned
6549 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6551 xappConn1.TestMsgChanEmpty(t)
6552 e2termConn1.TestMsgChanEmpty(t)
6553 mainCtrl.wait_registry_empty(t, 10)
6554 mainCtrl.VerifyAllClean(t)
6557 //-----------------------------------------------------------------------------
6558 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
6561 // +-------+ +---------+ +---------+
6562 // | xapp | | submgr | | e2term |
6563 // +-------+ +---------+ +---------+
6565 // | [SUBS CREATE] |
6568 // | RESTSubDelReq | |
6569 // |---------------->| |
6571 // | RESTSubDelResp | |
6572 // |<----------------| |
6575 // | |------------->|
6577 // | | SubDelResp | No transaction for the response
6578 // | |<-------------|
6581 // | |------------->|
6583 // | | SubDelFail | Subscription does exist any more
6584 // | |<-------------|
6586 //-----------------------------------------------------------------------------
6587 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
6588 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction")
6591 var params *teststube2ap.RESTSubsReqParams = nil
6592 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6595 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6597 // E2t: Receive 1st SubsDelReq
6598 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6600 mainCtrl.MakeTransactionNil(t, e2SubsId)
6602 // No transaction exist for this response which will result resending original request
6603 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6605 // E2t: Receive 2nd SubsDelReq
6606 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6608 // Subscription does not exist in in E2 Node.
6609 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6611 // Wait that subs is cleaned
6612 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6614 xappConn1.TestMsgChanEmpty(t)
6615 e2termConn1.TestMsgChanEmpty(t)
6616 mainCtrl.wait_registry_empty(t, 10)
6617 mainCtrl.VerifyAllClean(t)
6620 //-----------------------------------------------------------------------------
6621 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
6624 // +-------+ +---------+ +---------+
6625 // | xapp | | submgr | | e2term |
6626 // +-------+ +---------+ +---------+
6628 // | [SUBS CREATE] |
6631 // | RESTSubDelReq | |
6632 // |---------------->| |
6634 // | RESTSubDelResp | |
6635 // |<----------------| |
6638 // | |------------->|
6640 // | | SubDelFail | ASN.1 decode fails
6641 // | |<-------------|
6644 // | |------------->|
6646 // | | SubDelFail | Subscription does exist any more
6647 // | |<-------------|
6649 //-----------------------------------------------------------------------------
6650 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
6651 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail")
6654 var params *teststube2ap.RESTSubsReqParams = nil
6655 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6658 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6660 // E2t: Receive 1st SubsDelReq
6661 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6663 // Decode of this response fails which will result resending original request
6664 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
6666 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6667 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6669 // Subscription does not exist in in E2 Node.
6670 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6672 // Wait that subs is cleaned
6673 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6675 xappConn1.TestMsgChanEmpty(t)
6676 e2termConn1.TestMsgChanEmpty(t)
6677 mainCtrl.wait_registry_empty(t, 10)
6678 mainCtrl.VerifyAllClean(t)
6681 //-----------------------------------------------------------------------------
6682 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
6685 // +-------+ +---------+ +---------+
6686 // | xapp | | submgr | | e2term |
6687 // +-------+ +---------+ +---------+
6689 // | [SUBS CREATE] |
6692 // | RESTSubDelReq | |
6693 // |---------------->| |
6695 // | RESTSubDelResp | |
6696 // |<----------------| |
6699 // | |------------->|
6701 // | | SubDelFail | Unknown instanceId
6702 // | |<-------------|
6705 // | |------------->|
6707 // | | SubDelFail | Subscription does exist any more
6708 // | |<-------------|
6710 //-----------------------------------------------------------------------------
6711 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
6712 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId")
6715 var params *teststube2ap.RESTSubsReqParams = nil
6716 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6719 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6721 // E2t: Receive 1st SubsDelReq
6722 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6724 // Unknown instanceId in this response which will result resending original request
6725 delreq.RequestId.InstanceId = 0
6726 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6728 // E2t: Receive 2nd SubsDelReq
6729 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6731 // Subscription does not exist in in E2 Node.
6732 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6734 // Wait that subs is cleaned
6735 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6737 xappConn1.TestMsgChanEmpty(t)
6738 e2termConn1.TestMsgChanEmpty(t)
6739 mainCtrl.wait_registry_empty(t, 10)
6740 mainCtrl.VerifyAllClean(t)
6743 //-----------------------------------------------------------------------------
6744 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
6747 // +-------+ +---------+ +---------+
6748 // | xapp | | submgr | | e2term |
6749 // +-------+ +---------+ +---------+
6751 // | [SUBS CREATE] |
6754 // | RESTSubDelReq | |
6755 // |---------------->| |
6757 // | RESTSubDelResp | |
6758 // |<----------------| |
6761 // | |------------->|
6763 // | | SubDelFail | No transaction for the response
6764 // | |<-------------|
6767 // | |------------->|
6769 // | | SubDelFail | Subscription does exist any more
6770 // | |<-------------|
6772 //-----------------------------------------------------------------------------
6773 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
6774 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction")
6777 var params *teststube2ap.RESTSubsReqParams = nil
6778 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6781 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6783 // E2t: Receive 1st SubsDelReq
6784 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6786 mainCtrl.MakeTransactionNil(t, e2SubsId)
6788 // No transaction exist for this response which will result resending original request
6789 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6791 // E2t: Receive 2nd SubsDelReq
6792 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6794 // Subscription does not exist in in E2 Node.
6795 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6797 // Wait that subs is cleaned
6798 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6800 xappConn1.TestMsgChanEmpty(t)
6801 e2termConn1.TestMsgChanEmpty(t)
6802 mainCtrl.wait_registry_empty(t, 10)
6803 mainCtrl.VerifyAllClean(t)
6806 //-----------------------------------------------------------------------------
6807 // TestRESTSubReqFailAsn1PackSubReqError
6810 // +-------+ +---------+ +---------+
6811 // | xapp | | submgr | | e2term |
6812 // +-------+ +---------+ +---------+
6815 // |---------------->| |
6817 // | RESTSubResp | |
6818 // |<----------------| |
6820 // | ASN.1 encode fails |
6823 // | |------------->|
6826 // | |<-------------|
6830 // |<----------------| |
6832 // | [SUBS DELETE] |
6835 //-----------------------------------------------------------------------------
6836 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
6838 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6839 Counter{cRestSubReqFromXapp, 1},
6840 Counter{cRestSubRespToXapp, 1},
6841 Counter{cRestSubFailNotifToXapp, 1},
6842 Counter{cRestSubDelReqFromXapp, 1},
6843 Counter{cRestSubDelRespToXapp, 1},
6846 const subReqCount int = 1
6848 var params *teststube2ap.RESTSubsReqParams = nil
6849 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
6850 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
6853 restSubId := xappConn1.SendRESTSubsReq(t, params)
6854 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
6856 // E2t: Receive SubsDelReq
6857 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6859 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6860 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
6862 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
6864 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6866 // Wait that subs is cleaned
6867 waitSubsCleanup(t, e2SubsId, 10)
6868 mainCtrl.VerifyCounterValues(t)
6869 mainCtrl.VerifyAllClean(t)
6872 func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
6873 CaseBegin("TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction")
6875 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6876 Counter{cRestSubReqFromXapp, 2},
6877 Counter{cRestSubRespToXapp, 2},
6878 Counter{cSubReqToE2, 2},
6879 Counter{cSubReqTimerExpiry, 1},
6880 Counter{cSubRespFromE2, 1},
6881 Counter{cRestSubNotifToXapp, 1},
6882 Counter{cRestSubFailNotifToXapp, 1},
6883 Counter{cRestSubDelReqFromXapp, 1},
6884 Counter{cSubDelReqToE2, 1},
6885 Counter{cSubDelRespFromE2, 1},
6886 Counter{cRestSubDelRespToXapp, 1},
6889 const e2Timeout int64 = 1
6890 const e2RetryCount int64 = 0
6891 const routingNeeded bool = false
6894 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6895 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6898 restSubId := xappConn1.SendRESTSubsReq(t, params)
6899 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6901 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6902 xappConn1.ExpectRESTNotification(t, restSubId)
6903 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
6904 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6905 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
6908 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6909 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6910 params.SetSubscriptionID(&restSubId)
6911 params.SetTimeToWait("w200ms")
6912 restSubId = xappConn1.SendRESTSubsReq(t, params)
6913 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6915 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
6916 xappConn1.ExpectRESTNotification(t, restSubId)
6917 // SubsResp is missing, e2SubsId will be 0
6918 zeroE2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6919 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", zeroE2SubsId)
6922 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6923 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6924 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6926 waitSubsCleanup(t, e2SubsId, 10)
6928 mainCtrl.VerifyCounterValues(t)
6929 mainCtrl.VerifyAllClean(t)
6932 //-----------------------------------------------------------------------------
6933 // TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle
6936 // +-------+ +---------+ +---------+
6937 // | xapp | | submgr | | e2term |
6938 // +-------+ +---------+ +---------+
6941 // |---------------->| |
6943 // | RESTSubResp | |
6944 // |<----------------| |
6946 // | |------------->|
6949 // | |<-------------|
6952 // |<----------------| |
6955 // |---------------->| |
6957 // | RESTSubResp | |
6958 // |<----------------| |
6960 // | |------------->|
6962 // | Submgr restart |
6964 // | RESTSubDelReq | |
6965 // |---------------->| |
6968 // | |------------->|
6971 // | |<-------------|
6973 // | RESTSubDelResp | |
6974 // |<----------------| |
6976 //-----------------------------------------------------------------------------
6978 func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
6979 CaseBegin("TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle")
6981 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6982 Counter{cRestSubReqFromXapp, 2},
6983 Counter{cRestSubRespToXapp, 2},
6984 Counter{cSubReqToE2, 2},
6985 Counter{cSubRespFromE2, 1},
6986 Counter{cRestSubNotifToXapp, 1},
6987 Counter{cRestSubDelReqFromXapp, 1},
6988 Counter{cSubDelReqToE2, 1},
6989 Counter{cSubDelRespFromE2, 1},
6990 Counter{cRestSubDelRespToXapp, 1},
6993 const e2Timeout int64 = 1
6994 const e2RetryCount int64 = 0
6995 const routingNeeded bool = false
6998 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6999 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7000 // Create subscription
7001 restSubId := xappConn1.SendRESTSubsReq(t, params)
7002 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
7004 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7005 xappConn1.ExpectRESTNotification(t, restSubId)
7006 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
7007 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7008 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7010 // Check subscription
7011 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
7014 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7015 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7016 params.SetSubscriptionID(&restSubId)
7017 params.SetTimeToWait("w200ms")
7018 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
7019 restSubId = xappConn1.SendRESTSubsReq(t, params)
7020 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
7022 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
7023 mainCtrl.SetResetTestFlag(t, false)
7025 // SubsResp is missing due to submgr restart
7027 mainCtrl.SimulateRestart(t)
7028 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
7030 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
7031 // That needs to be completed before successful subscription query is possible
7032 <-time.After(time.Second * 1)
7034 // Check subscription
7035 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
7037 // Delete subscription
7038 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7039 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7040 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7042 //Wait that subs is cleaned
7043 waitSubsCleanup(t, e2SubsId, 10)
7045 mainCtrl.VerifyCounterValues(t)
7046 mainCtrl.VerifyAllClean(t)
7049 ////////////////////////////////////////////////////////////////////////////////////
7050 // Services for UT cases
7051 ////////////////////////////////////////////////////////////////////////////////////
7052 const subReqCount int = 1
7053 const host string = "localhost"
7055 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
7057 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
7059 restSubId := fromXappConn.SendRESTSubsReq(t, params)
7060 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
7062 crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
7063 fromXappConn.ExpectRESTNotification(t, restSubId)
7064 toE2termConn.SendSubsResp(t, crereq1, cremsg1)
7065 e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
7066 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7068 return restSubId, e2SubsId
7071 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
7073 params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
7075 params.SetMeid(meid)
7077 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
7078 restSubId := xappConn2.SendRESTSubsReq(t, params)
7079 xappConn2.ExpectRESTNotification(t, restSubId)
7080 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
7081 e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
7082 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7084 return restSubId, e2SubsId
7087 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
7089 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7090 restSubId := xappConn1.SendRESTSubsReq(t, params)
7091 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
7093 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7094 xappConn1.ExpectRESTNotification(t, restSubId)
7095 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
7096 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7097 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7099 return restSubId, e2SubsId
7102 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
7103 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7104 restSubId := xappConn1.SendRESTSubsReq(t, params)
7106 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7107 fparams1 := &teststube2ap.E2StubSubsFailParams{}
7108 fparams1.Set(crereq1)
7109 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
7111 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
7112 xappConn1.ExpectRESTNotification(t, restSubId)
7113 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
7114 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7115 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
7117 return restSubId, e2SubsId
7120 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
7121 fromXappConn.SendRESTSubsDelReq(t, restSubId)
7122 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
7123 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
7126 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
7127 xappConn1.SendRESTSubsDelReq(t, restSubId)
7128 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7129 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7132 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
7133 xappConn2.SendRESTSubsDelReq(t, restSubId)
7134 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7135 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7138 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
7139 resp, _ := xapp.Subscription.QuerySubscriptions()
7140 assert.Equal(t, e2SubsId, resp[0].SubscriptionID)
7141 assert.Equal(t, meid, resp[0].Meid)
7142 assert.Equal(t, endpoint, resp[0].ClientEndpoint)
7145 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
7146 //Wait that subs is cleaned
7147 mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
7149 xappConn1.TestMsgChanEmpty(t)
7150 xappConn2.TestMsgChanEmpty(t)
7151 e2termConn1.TestMsgChanEmpty(t)
7152 mainCtrl.wait_registry_empty(t, timeout)
7155 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
7157 var e2SubsId []uint32
7159 for i := 0; i < count; i++ {
7160 xapp.Logger.Debug("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
7161 crereq, cremsg := toE2termConn.RecvSubsReq(t)
7162 fromXappConn.ExpectRESTNotification(t, restSubId)
7163 toE2termConn.SendSubsResp(t, crereq, cremsg)
7164 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
7165 e2SubsId = append(e2SubsId, instanceId)
7166 xapp.Logger.Debug("TEST: %v", e2SubsId)
7167 xapp.Logger.Debug("TEST: %d ===================================== END CRE ============================================", i+1)
7168 <-time.After(100 * time.Millisecond)
7173 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
7175 for i := 0; i < len(e2SubsIds); i++ {
7176 xapp.Logger.Debug("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
7177 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
7178 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
7179 <-time.After(1 * time.Second)
7180 xapp.Logger.Debug("TEST: %d ===================================== END DEL ============================================", i+1)
7181 <-time.After(100 * time.Millisecond)
7184 // Wait that subs is cleaned
7185 for i := 0; i < len(e2SubsIds); i++ {
7186 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)