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"})
2986 mainCtrl.WaitOngoingRequestMapEmpty()
2989 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
2991 assert.Equal(t, restSubId_resend, restSubId)
2993 mainCtrl.WaitOngoingRequestMapEmpty()
2996 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
2998 assert.Equal(t, restSubId_resend2, restSubId)
3000 mainCtrl.WaitOngoingRequestMapEmpty()
3002 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3004 waitSubsCleanup(t, e2SubsId, 10)
3005 mainCtrl.VerifyCounterValues(t)
3006 mainCtrl.VerifyAllClean(t)
3009 //-----------------------------------------------------------------------------
3011 // +-------+ +---------+ +---------+ +---------+
3012 // | xapp | | submgr | | e2term | | rtmgr |
3013 // +-------+ +---------+ +---------+ +---------+
3015 // | RESTSubReq | | |
3016 // |---------------->| | |
3017 // | RESTSubResp | | |
3018 // |<----------------| | |
3019 // | | RouteCreate | |
3020 // | |--------------------------->|
3021 // | | RouteResponse| |
3022 // | |<---------------------------| // The order of these events may vary
3024 // | |------------->| | // The order of these events may vary
3026 // | |<-------------| |
3027 // | RESTNotif1 | | |
3028 // |<----------------| | |
3029 // | RESTSubReq | | |
3030 // | [RETRANS, with RESTsubsId] | |
3031 // |---------------->| | |
3032 // | RESTNotif1 | | |
3033 // |<----------------| | |
3034 // | RESTSubReq | | |
3035 // | [RETRANS, without RESTsubsId] | |
3036 // |---------------->| | |
3037 // | RESTNotif1 | | |
3038 // |<----------------| | |
3039 // | RESTSubDelReq | | |
3040 // |---------------->| | |
3041 // | | SubDelReq | |
3042 // | |------------->| |
3043 // | RESTSubDelResp| | |
3044 // |<----------------| | |
3045 // | | SubDelResp | |
3046 // | |<-------------| |
3049 //-----------------------------------------------------------------------------
3050 func TestRESTSubReqRetransmissionV3(t *testing.T) {
3051 CaseBegin("TestRESTSubReqRetransmissionV3")
3053 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3054 Counter{cRestSubReqFromXapp, 3},
3055 Counter{cDuplicateE2SubReq, 2},
3056 Counter{cRestSubRespToXapp, 3},
3057 Counter{cSubReqToE2, 1},
3058 Counter{cSubRespFromE2, 1},
3059 Counter{cRestSubNotifToXapp, 3},
3060 Counter{cRestSubDelReqFromXapp, 1},
3061 Counter{cSubDelReqToE2, 1},
3062 Counter{cSubDelRespFromE2, 1},
3063 Counter{cRestSubDelRespToXapp, 1},
3066 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3068 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3070 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3072 mainCtrl.WaitOngoingRequestMapEmpty()
3074 //1.st resend with subscription ID
3075 params.SetSubscriptionID(&restSubId)
3076 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
3078 assert.Equal(t, restSubId_resend, restSubId)
3080 mainCtrl.WaitOngoingRequestMapEmpty()
3082 //2.nd resend without subscription ID (faking app restart)
3083 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3084 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3086 assert.Equal(t, restSubId_resend2, restSubId)
3088 mainCtrl.WaitOngoingRequestMapEmpty()
3090 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3092 waitSubsCleanup(t, e2SubsId, 10)
3093 mainCtrl.VerifyCounterValues(t)
3094 mainCtrl.VerifyAllClean(t)
3097 //-----------------------------------------------------------------------------
3099 // +-------+ +---------+ +---------+ +---------+
3100 // | xapp | | submgr | | e2term | | rtmgr |
3101 // +-------+ +---------+ +---------+ +---------+
3103 // | RESTSubReq | | |
3104 // |---------------->| | |
3105 // | RESTSubResp | | |
3106 // |<----------------| | |
3107 // | | RouteCreate | |
3108 // | |--------------------------->|
3109 // | | RouteResponse| |
3110 // | |<---------------------------|
3112 // | |------------->| |
3114 // | |<-------------| |
3115 // | RESTNotif1 | | |
3116 // |<----------------| | |
3117 // | RESTSubReq | | |
3118 // | [with RestSUbsId + one additional e2 subDetail]
3119 // |---------------->| | |
3120 // | RESTNotif1 | | |
3121 // | [for initial e2 subDetail] | |
3122 // |<----------------| | |
3123 // | | RouteCreate | |
3124 // | |--------------------------->|
3125 // | | RouteResponse| |
3126 // | |<---------------------------|
3128 // | |------------->| |
3130 // | |<-------------| |
3131 // | RESTNotif1 | | |
3132 // |<----------------| | |
3133 // | RESTSubReq | | |
3134 // | [with RESTsubsId initial request] |
3135 // |---------------->| | |
3136 // | RESTNotif1 | | |
3137 // |<----------------| | |
3138 // | RESTSubDelReq | | |
3139 // |---------------->| | |
3140 // | RESTSubDelResp| | |
3141 // |<----------------| | |
3142 // | | SubDelReq | |
3143 // | |------------->| |
3144 // | | SubDelResp | |
3145 // | |<-------------| |
3146 // | | SubDelReq | |
3147 // | |------------->| |
3148 // | | SubDelResp | |
3149 // | |<-------------| |
3152 //-----------------------------------------------------------------------------
3154 func TestRESTSubReqRetransmissionV4(t *testing.T) {
3155 CaseBegin("TestRESTSubReqRetransmissionV4")
3157 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3158 Counter{cRestSubReqFromXapp, 3},
3159 Counter{cDuplicateE2SubReq, 2},
3160 Counter{cRestSubRespToXapp, 3},
3161 Counter{cSubReqToE2, 2},
3162 Counter{cSubRespFromE2, 2},
3163 Counter{cRestSubNotifToXapp, 4},
3164 Counter{cRestSubDelReqFromXapp, 1},
3165 Counter{cSubDelReqToE2, 2},
3166 Counter{cSubDelRespFromE2, 2},
3167 Counter{cRestSubDelRespToXapp, 1},
3170 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3172 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3174 mainCtrl.WaitOngoingRequestMapEmpty()
3176 // Send modified requst, this time with e2 subscriptions.
3177 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3178 params2.SetSubscriptionID(&restSubId)
3180 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3181 xappConn1.ExpectAnyNotification(t)
3182 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3183 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3184 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3185 assert.Equal(t, e2SubsId, e2SubsId1)
3187 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3189 xappConn1.DecrementRequestCount()
3190 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3191 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3192 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3193 assert.NotEqual(t, e2SubsId2, 0)
3195 mainCtrl.WaitOngoingRequestMapEmpty()
3197 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3198 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3199 params.SetSubscriptionID(&restSubId)
3200 xappConn1.ExpectAnyNotification(t)
3201 // Resend the original request again with only one e2 subscription (detail), this time with restsubsid
3202 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3203 assert.Equal(t, restSubId_resend, restSubId_resend2)
3205 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3206 assert.Equal(t, e2SubsId, e2SubsId1)
3208 mainCtrl.WaitOngoingRequestMapEmpty()
3210 // Delete both e2 subscriptions
3211 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3212 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3213 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3215 waitSubsCleanup(t, e2SubsId, 10)
3216 mainCtrl.VerifyCounterValues(t)
3217 mainCtrl.VerifyAllClean(t)
3220 //-----------------------------------------------------------------------------
3222 // +-------+ +---------+ +---------+ +---------+
3223 // | xapp | | submgr | | e2term | | rtmgr |
3224 // +-------+ +---------+ +---------+ +---------+
3226 // | RESTSubReq | | |
3227 // |---------------->| | |
3228 // | RESTSubResp | | |
3229 // |<----------------| | |
3230 // | | RouteCreate | |
3231 // | |--------------------------->|
3232 // | | RouteResponse| |
3233 // | |<---------------------------|
3235 // | |------------->| |
3237 // | |<-------------| |
3238 // | RESTNotif1 | | |
3239 // |<----------------| | |
3240 // | RESTSubReq | | |
3241 // | [with RestSUbsId + one additional e2 subDetail]
3242 // |---------------->| | |
3243 // | RESTNotif1 | | |
3244 // | [for initial e2 subDetail] | |
3245 // |<----------------| | |
3246 // | | RouteCreate | |
3247 // | |--------------------------->|
3248 // | | RouteResponse| |
3249 // | |<---------------------------|
3251 // | |------------->| |
3253 // | |<-------------| |
3254 // | RESTNotif1 | | |
3255 // |<----------------| | |
3256 // | RESTSubReq | | |
3257 // | [without RESTsubsId initial request] |
3258 // |---------------->| | |
3259 // | RESTNotif1 | | |
3260 // |<----------------| | |
3261 // | RESTSubDelReq | | |
3262 // |---------------->| | |
3263 // | RESTSubDelResp| | |
3264 // |<----------------| | |
3265 // | | SubDelReq | |
3266 // | |------------->| |
3267 // | | SubDelResp | |
3268 // | |<-------------| |
3269 // | | SubDelReq | |
3270 // | |------------->| |
3271 // | | SubDelResp | |
3272 // | |<-------------| |
3275 //-----------------------------------------------------------------------------
3277 func TestRESTSubReqRetransmissionV5(t *testing.T) {
3278 CaseBegin("TestRESTSubReqRetransmissionV5")
3280 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3281 Counter{cRestSubReqFromXapp, 3},
3282 Counter{cDuplicateE2SubReq, 2},
3283 Counter{cRestSubRespToXapp, 3},
3284 Counter{cSubReqToE2, 2},
3285 Counter{cSubRespFromE2, 2},
3286 Counter{cRestSubNotifToXapp, 4},
3287 Counter{cRestSubDelReqFromXapp, 1},
3288 Counter{cSubDelReqToE2, 2},
3289 Counter{cSubDelRespFromE2, 2},
3290 Counter{cRestSubDelRespToXapp, 1},
3293 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3295 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3297 mainCtrl.WaitOngoingRequestMapEmpty()
3299 // Send modified requst, this time with e2 subscriptions.
3300 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3301 params2.SetSubscriptionID(&restSubId)
3303 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3304 xappConn1.ExpectAnyNotification(t)
3305 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3306 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3308 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3309 assert.Equal(t, e2SubsId, e2SubsId1)
3310 // The first E2 subscription returns immediately, manually decrement expected request count for the remaining request handling
3311 xappConn1.DecrementRequestCount()
3313 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3315 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3316 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3317 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3318 assert.NotEqual(t, e2SubsId2, 0)
3320 mainCtrl.WaitOngoingRequestMapEmpty()
3322 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3323 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3324 xappConn1.ExpectAnyNotification(t)
3325 // Resend the original request again with only one e2 subscription (detail), WITHOUT restsubsid
3326 // md5sum shall find the original request
3327 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3328 assert.Equal(t, restSubId_resend, restSubId_resend2)
3330 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3331 assert.Equal(t, e2SubsId, e2SubsId1)
3333 mainCtrl.WaitOngoingRequestMapEmpty()
3335 // Delete both e2 subscriptions
3336 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3337 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3338 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3340 waitSubsCleanup(t, e2SubsId, 10)
3341 mainCtrl.VerifyCounterValues(t)
3342 mainCtrl.VerifyAllClean(t)
3345 //-----------------------------------------------------------------------------
3347 // +-------+ +---------+ +---------+ +---------+
3348 // | xapp | | submgr | | e2term | | rtmgr |
3349 // +-------+ +---------+ +---------+ +---------+
3351 // | RESTSubReq | | |
3352 // |---------------->| | |
3353 // | RESTSubResp | | |
3354 // |<----------------| | |
3355 // | | RouteCreate | |
3356 // | |--------------------------->|
3357 // | | RouteResponse| |
3358 // | |<---------------------------|
3360 // | |------------->| |
3362 // | |<-------------| |
3363 // | RESTNotif1 | | |
3364 // |<----------------| | |
3365 // | RESTSubReq | | |
3366 // | [with RestSUbsId + one additional e2 subDetail]
3367 // |---------------->| | |
3368 // | RESTNotif1 | | |
3369 // | [for initial e2 subDetail] | |
3370 // |<----------------| | |
3371 // | | RouteCreate | |
3372 // | |--------------------------->|
3373 // | | RouteResponse| |
3374 // | |<---------------------------|
3376 // | |------------->| |
3378 // | |<-------------| |
3379 // | RESTNotif1 | | |
3380 // |<----------------| | |
3381 // | RESTSubDelReq | | |
3382 // |---------------->| | |
3383 // | RESTSubDelResp| | |
3384 // |<----------------| | |
3385 // | | SubDelReq | |
3386 // | |------------->| |
3387 // | | SubDelResp | |
3388 // | |<-------------| |
3389 // | | SubDelReq | |
3390 // | |------------->| |
3391 // | | SubDelResp | |
3392 // | |<-------------| |
3393 // | RESTSubReq | | |
3394 // | [with RESTsubsId initial request] |
3395 // |---------------->| | |
3396 // | RESTSubResp | | |
3397 // |<----------------| | |
3398 // | | RouteCreate | |
3399 // | |--------------------------->|
3400 // | | RouteResponse| |
3401 // | |<---------------------------|
3403 // | |------------->| |
3405 // | |<-------------| |
3406 // | RESTNotif1 | | |
3407 // |<----------------| | |
3410 //-----------------------------------------------------------------------------
3411 func TestRESTSubReqRetransmissionV6(t *testing.T) {
3412 CaseBegin("TestRESTSubReqRetransmissionV6")
3414 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3415 Counter{cRestSubReqFromXapp, 3},
3416 Counter{cDuplicateE2SubReq, 1},
3417 Counter{cRestSubRespToXapp, 3},
3418 Counter{cSubReqToE2, 3},
3419 Counter{cSubRespFromE2, 3},
3420 Counter{cRestSubNotifToXapp, 4},
3421 Counter{cRestSubDelReqFromXapp, 2},
3422 Counter{cSubDelReqToE2, 3},
3423 Counter{cSubDelRespFromE2, 3},
3424 Counter{cRestSubDelRespToXapp, 2},
3427 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3429 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3431 mainCtrl.WaitOngoingRequestMapEmpty()
3433 // Send modified requst, this time with e2 subscriptions.
3434 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3435 params2.SetSubscriptionID(&restSubId)
3437 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3438 xappConn1.ExpectAnyNotification(t)
3439 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3440 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3442 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3443 assert.Equal(t, e2SubsId, e2SubsId1)
3445 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3447 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3448 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3449 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3450 assert.NotEqual(t, e2SubsId2, 0)
3452 mainCtrl.WaitOngoingRequestMapEmpty()
3454 // Delete both e2 subscriptions
3455 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3456 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3457 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3459 waitSubsCleanup(t, e2SubsId, 10)
3461 // Resend the original request, we shall find it's previous md5sum/restsubs
3462 // but the restsubscription has been already removed. This shall trigger a
3464 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
3466 mainCtrl.WaitOngoingRequestMapEmpty()
3468 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3470 waitSubsCleanup(t, e2SubsId, 10)
3471 mainCtrl.VerifyCounterValues(t)
3472 mainCtrl.VerifyAllClean(t)
3475 func TestRESTSubDelReqRetransmission(t *testing.T) {
3476 CaseBegin("TestRESTSubDelReqRetransmission")
3478 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3479 Counter{cRestSubReqFromXapp, 1},
3480 Counter{cRestSubRespToXapp, 1},
3481 Counter{cSubReqToE2, 1},
3482 Counter{cSubRespFromE2, 1},
3483 Counter{cRestSubNotifToXapp, 1},
3484 Counter{cRestSubDelReqFromXapp, 2},
3485 Counter{cSubDelReqToE2, 1},
3486 Counter{cSubDelRespFromE2, 1},
3487 Counter{cRestSubDelRespToXapp, 2},
3490 var params *teststube2ap.RESTSubsReqParams = nil
3493 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3495 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3498 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3499 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3501 seqBef := mainCtrl.get_msgcounter(t)
3502 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3503 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
3505 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3507 waitSubsCleanup(t, e2SubsId, 10)
3508 mainCtrl.VerifyCounterValues(t)
3509 mainCtrl.VerifyAllClean(t)
3512 //-----------------------------------------------------------------------------
3513 // TestRESTSubReqDelReq
3516 // +-------+ +---------+ +---------+
3517 // | xapp | | submgr | | e2term |
3518 // +-------+ +---------+ +---------+
3521 // |---------------->| |
3523 // | RESTSubResp | |
3524 // |<----------------| |
3526 // | |------------->|
3527 // | RESTSubDelReq | |
3528 // |---------------->| |
3529 // | RESTSubDelResp | |
3531 // |<----------------| |
3533 // | |<-------------|
3535 // |<----------------| |
3537 // | [SUBS DELETE] |
3540 //-----------------------------------------------------------------------------
3541 func TestRESTSubReqDelReq(t *testing.T) {
3542 CaseBegin("TestRESTSubReqDelReq")
3544 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3545 Counter{cRestSubReqFromXapp, 1},
3546 Counter{cRestSubRespToXapp, 1},
3547 Counter{cSubReqToE2, 1},
3548 Counter{cSubRespFromE2, 1},
3549 Counter{cRestSubNotifToXapp, 1},
3550 Counter{cRestSubDelReqFromXapp, 2},
3551 Counter{cRestSubDelFailToXapp, 1},
3552 Counter{cSubDelReqToE2, 1},
3553 Counter{cSubDelRespFromE2, 1},
3554 Counter{cRestSubDelRespToXapp, 1},
3557 const subReqCount int = 1
3560 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3561 restSubId := xappConn1.SendRESTSubsReq(t, params)
3563 // Del. This will fail as processing of the subscription
3564 // is still ongoing in submgr. Deletion is not allowed before
3565 // subscription creation has been completed.
3566 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3567 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3568 xappConn1.ExpectRESTNotification(t, restSubId)
3569 e2termConn1.SendSubsResp(t, crereq, cremsg)
3570 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3573 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3575 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3576 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3578 // Wait that subs is cleaned
3579 waitSubsCleanup(t, e2SubsId, 10)
3580 mainCtrl.VerifyCounterValues(t)
3581 mainCtrl.VerifyAllClean(t)
3584 func TestRESTSubDelReqCollision(t *testing.T) {
3585 CaseBegin("TestRESTSubDelReqCollision - not relevant for REST API")
3588 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
3589 CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel")
3591 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3592 Counter{cRestSubReqFromXapp, 2},
3593 Counter{cRestSubRespToXapp, 2},
3594 Counter{cSubReqToE2, 2},
3595 Counter{cSubRespFromE2, 2},
3596 Counter{cRestSubNotifToXapp, 2},
3597 Counter{cRestSubDelReqFromXapp, 2},
3598 Counter{cSubDelReqToE2, 2},
3599 Counter{cSubDelRespFromE2, 2},
3600 Counter{cRestSubDelRespToXapp, 2},
3604 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3605 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3606 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3609 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3610 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3611 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3613 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3614 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3616 //XappConn1 receives both of the responses
3617 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3620 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3622 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3624 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3625 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3626 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3627 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3630 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3632 deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
3634 //Wait that subs is cleaned
3635 mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
3636 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
3638 mainCtrl.VerifyCounterValues(t)
3639 mainCtrl.VerifyAllClean(t)
3642 func TestRESTSameSubsDiffRan(t *testing.T) {
3643 CaseBegin("TestRESTSameSubsDiffRan")
3645 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3646 Counter{cRestSubReqFromXapp, 2},
3647 Counter{cRestSubRespToXapp, 2},
3648 Counter{cSubReqToE2, 2},
3649 Counter{cSubRespFromE2, 2},
3650 Counter{cRestSubNotifToXapp, 2},
3651 Counter{cRestSubDelReqFromXapp, 2},
3652 Counter{cSubDelReqToE2, 2},
3653 Counter{cSubDelRespFromE2, 2},
3654 Counter{cRestSubDelRespToXapp, 2},
3657 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3658 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3659 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3661 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3662 params.SetMeid("RAN_NAME_2")
3663 restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
3664 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3667 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3669 deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
3671 //Wait that subs is cleaned
3672 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3673 waitSubsCleanup(t, e2SubsId2, 10)
3675 mainCtrl.VerifyCounterValues(t)
3676 mainCtrl.VerifyAllClean(t)
3679 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
3680 CaseBegin("TestRESTSubReqRetryInSubmgr start")
3682 // Init counter check
3683 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3684 Counter{cRestSubReqFromXapp, 1},
3685 Counter{cRestSubRespToXapp, 1},
3686 Counter{cSubReqToE2, 1},
3687 Counter{cSubReqTimerExpiry, 1},
3688 Counter{cSubReReqToE2, 1},
3689 Counter{cSubRespFromE2, 1},
3690 Counter{cRestSubNotifToXapp, 1},
3691 Counter{cRestSubDelReqFromXapp, 1},
3692 Counter{cSubDelReqToE2, 1},
3693 Counter{cSubDelRespFromE2, 1},
3694 Counter{cRestSubDelRespToXapp, 1},
3697 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3698 restSubId := xappConn1.SendRESTSubsReq(t, params)
3700 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3702 // Catch the first message and ignore it
3703 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3704 xapp.Logger.Debug("Ignore REST subscriber request for subscriber : %v", restSubId)
3706 // The second request is being handled normally
3707 crereq, cremsg = e2termConn1.RecvSubsReq(t)
3708 xappConn1.ExpectRESTNotification(t, restSubId)
3709 e2termConn1.SendSubsResp(t, crereq, cremsg)
3710 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3712 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3714 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3716 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
3717 //Wait that subs is cleaned
3718 waitSubsCleanup(t, e2SubsId, 10)
3720 mainCtrl.VerifyCounterValues(t)
3721 mainCtrl.VerifyAllClean(t)
3724 //-----------------------------------------------------------------------------
3725 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3728 // +-------+ +---------+ +---------+
3729 // | xapp | | submgr | | e2term |
3730 // +-------+ +---------+ +---------+
3733 // |---------------->| |
3735 // | RESTSubResp | |
3736 // |<----------------| |
3738 // | |------------->|
3742 // | |------------->|
3745 // | |------------->|
3749 // | |------------->|
3753 // | |<-------------|
3756 // |<----------------| |
3758 // | [SUBS DELETE] |
3761 //-----------------------------------------------------------------------------
3763 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
3764 CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
3766 // Init counter check
3767 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3768 Counter{cRestSubReqFromXapp, 1},
3769 Counter{cRestSubRespToXapp, 1},
3770 Counter{cSubReqToE2, 1},
3771 Counter{cSubReReqToE2, 1},
3772 Counter{cSubReqTimerExpiry, 2},
3773 Counter{cRestSubFailNotifToXapp, 1},
3774 Counter{cSubDelReqToE2, 1},
3775 Counter{cSubDelRespFromE2, 1},
3776 Counter{cRestSubDelReqFromXapp, 1},
3777 Counter{cRestSubDelRespToXapp, 1},
3780 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3781 restSubId := xappConn1.SendRESTSubsReq(t, params)
3782 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3784 e2termConn1.RecvSubsReq(t)
3785 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3787 e2termConn1.RecvSubsReq(t)
3788 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3790 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3791 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3792 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3793 xappConn1.WaitRESTNotification(t, restSubId)
3795 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3797 // Wait that subs is cleaned
3798 waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
3799 mainCtrl.VerifyCounterValues(t)
3800 mainCtrl.VerifyAllClean(t)
3803 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
3804 CaseBegin("TestREST2eTermNotRespondingToSubReq start")
3806 // Init counter check
3807 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3808 Counter{cRestSubReqFromXapp, 1},
3809 Counter{cRestSubRespToXapp, 1},
3810 Counter{cSubReqToE2, 1},
3811 Counter{cSubReReqToE2, 1},
3812 Counter{cSubReqTimerExpiry, 2},
3813 Counter{cSubDelReReqToE2, 1},
3814 Counter{cRestSubFailNotifToXapp, 1},
3815 Counter{cSubDelReqToE2, 1},
3816 Counter{cSubDelReqTimerExpiry, 2},
3817 Counter{cRestSubDelReqFromXapp, 1},
3818 Counter{cRestSubDelRespToXapp, 1},
3821 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3822 restSubId := xappConn1.SendRESTSubsReq(t, params)
3823 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3825 e2termConn1.RecvSubsReq(t)
3826 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3828 e2termConn1.RecvSubsReq(t)
3829 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3831 e2termConn1.RecvSubsDelReq(t)
3832 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3834 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3835 e2termConn1.RecvSubsDelReq(t)
3836 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3838 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3840 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3842 waitSubsCleanup(t, e2SubsId, 10)
3843 mainCtrl.VerifyCounterValues(t)
3844 mainCtrl.VerifyAllClean(t)
3847 //-----------------------------------------------------------------------------
3848 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3851 // +-------+ +---------+ +---------+
3852 // | xapp | | submgr | | e2term |
3853 // +-------+ +---------+ +---------+
3856 // |---------------->| |
3858 // | RESTSubResp | |
3859 // |<----------------| |
3861 // | |------------->|
3865 // | |------------->|
3868 // | |------------->|
3872 // | |------------->|
3876 // | |<-------------|
3879 // |<----------------| |
3881 // | [SUBS DELETE] |
3884 //-----------------------------------------------------------------------------
3885 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
3886 CaseBegin("TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr start")
3888 // Init counter check
3889 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3890 Counter{cRestSubReqFromXapp, 1},
3891 Counter{cRestSubRespToXapp, 1},
3892 Counter{cSubReqToE2, 1},
3893 Counter{cSubReReqToE2, 1},
3894 Counter{cSubReqTimerExpiry, 2},
3895 Counter{cRestSubFailNotifToXapp, 1},
3896 Counter{cSubDelReqToE2, 1},
3897 Counter{cSubDelReReqToE2, 1},
3898 Counter{cSubDelReqTimerExpiry, 2},
3899 Counter{cRestSubDelReqFromXapp, 1},
3900 Counter{cRestSubDelRespToXapp, 1},
3903 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3904 restSubId := xappConn1.SendRESTSubsReq(t, params)
3905 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3907 e2termConn1.RecvSubsReq(t)
3908 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3910 e2termConn1.RecvSubsReq(t)
3911 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3913 e2termConn1.RecvSubsDelReq(t)
3914 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3916 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3917 e2termConn1.RecvSubsDelReq(t)
3918 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3920 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3922 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3924 waitSubsCleanup(t, e2SubsId, 10)
3925 mainCtrl.VerifyCounterValues(t)
3926 mainCtrl.VerifyAllClean(t)
3929 //-----------------------------------------------------------------------------
3930 // TestRESTSubReqSubFailRespInSubmgr
3933 // +-------+ +---------+ +---------+
3934 // | xapp | | submgr | | e2term |
3935 // +-------+ +---------+ +---------+
3938 // |---------------->| |
3940 // | RESTSubResp | |
3941 // |<----------------| |
3943 // | |------------->|
3946 // | |<-------------|
3950 // |<----------------| |
3952 // | [SUBS DELETE] |
3955 //-----------------------------------------------------------------------------
3956 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
3957 CaseBegin("TestRESTSubReqSubFailRespInSubmgr")
3959 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3960 Counter{cRestSubReqFromXapp, 1},
3961 Counter{cRestSubRespToXapp, 1},
3962 Counter{cSubReqToE2, 1},
3963 Counter{cSubFailFromE2, 1},
3964 Counter{cRestSubFailNotifToXapp, 1},
3965 Counter{cRestSubDelReqFromXapp, 1},
3966 Counter{cRestSubDelRespToXapp, 1},
3969 const subReqCount int = 1
3970 const e2Timeout int64 = 2
3971 const e2RetryCount int64 = 1
3972 const routingNeeded bool = true
3974 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3975 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
3976 restSubId := xappConn1.SendRESTSubsReq(t, params)
3978 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3979 fparams1 := &teststube2ap.E2StubSubsFailParams{}
3980 fparams1.Set(crereq1)
3981 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3982 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3984 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3985 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
3987 // REST subscription sill there to be deleted
3988 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3990 // Wait that subs is cleaned
3991 waitSubsCleanup(t, e2SubsId, 10)
3993 mainCtrl.VerifyCounterValues(t)
3994 mainCtrl.VerifyAllClean(t)
3997 //-----------------------------------------------------------------------------
3998 // TestRESTSubDelReqRetryInSubmgr
4001 // +-------+ +---------+ +---------+
4002 // | xapp | | submgr | | e2term |
4003 // +-------+ +---------+ +---------+
4005 // | [SUBS CREATE] |
4008 // | RESTSubDelReq | |
4009 // |---------------->| |
4011 // | RESTSubDelResp | |
4012 // |<----------------| |
4014 // | |------------->|
4017 // | |------------->|
4020 // | |<-------------|
4023 //-----------------------------------------------------------------------------
4024 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
4025 CaseBegin("TestRESTSubDelReqRetryInSubmgr")
4027 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4028 Counter{cRestSubReqFromXapp, 1},
4029 Counter{cRestSubRespToXapp, 1},
4030 Counter{cSubReqToE2, 1},
4031 Counter{cSubRespFromE2, 1},
4032 Counter{cRestSubNotifToXapp, 1},
4033 Counter{cRestSubDelReqFromXapp, 1},
4034 Counter{cSubDelReqToE2, 1},
4035 Counter{cSubDelReqTimerExpiry, 1},
4036 Counter{cSubDelReReqToE2, 1},
4037 Counter{cSubDelRespFromE2, 1},
4038 Counter{cRestSubDelRespToXapp, 1},
4041 var params *teststube2ap.RESTSubsReqParams = nil
4042 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4045 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4047 // E2t: Receive 1st SubsDelReq
4048 e2termConn1.RecvSubsDelReq(t)
4050 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4051 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4052 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4054 //Wait that subs is cleaned
4055 waitSubsCleanup(t, e2SubsId, 10)
4057 mainCtrl.VerifyCounterValues(t)
4058 mainCtrl.VerifyAllClean(t)
4061 //-----------------------------------------------------------------------------
4062 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
4065 // +-------+ +---------+ +---------+
4066 // | xapp | | submgr | | e2term |
4067 // +-------+ +---------+ +---------+
4069 // | [SUBS CREATE] |
4072 // | RESTSubDelReq | |
4073 // |---------------->| |
4075 // | RESTSubDelResp | |
4076 // |<----------------| |
4078 // | |------------->|
4081 // | |------------->|
4085 //-----------------------------------------------------------------------------
4086 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
4087 CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr")
4089 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4090 Counter{cRestSubReqFromXapp, 1},
4091 Counter{cRestSubRespToXapp, 1},
4092 Counter{cSubReqToE2, 1},
4093 Counter{cSubRespFromE2, 1},
4094 Counter{cRestSubNotifToXapp, 1},
4095 Counter{cRestSubDelReqFromXapp, 1},
4096 Counter{cSubDelReqToE2, 1},
4097 Counter{cSubDelReqTimerExpiry, 1},
4098 Counter{cSubDelReReqToE2, 1},
4099 Counter{cSubDelRespFromE2, 1},
4100 Counter{cRestSubDelRespToXapp, 1},
4104 var params *teststube2ap.RESTSubsReqParams = nil
4105 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4108 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4110 // E2t: Receive 1st SubsDelReq
4111 e2termConn1.RecvSubsDelReq(t)
4113 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4114 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4115 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4117 //Wait that subs is cleaned
4118 waitSubsCleanup(t, e2SubsId, 10)
4120 mainCtrl.VerifyCounterValues(t)
4121 mainCtrl.VerifyAllClean(t)
4124 //-----------------------------------------------------------------------------
4125 // TestRESTSubDelReqSubDelFailRespInSubmgr
4128 // +-------+ +---------+ +---------+
4129 // | xapp | | submgr | | e2term |
4130 // +-------+ +---------+ +---------+
4132 // | [SUBS CREATE] |
4135 // | RESTSubDelReq | |
4136 // |---------------->| |
4138 // | RESTSubDelResp | |
4139 // |<----------------| |
4141 // | |------------->|
4144 // | |<-------------|
4147 //-----------------------------------------------------------------------------
4148 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
4149 CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr")
4151 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4152 Counter{cRestSubReqFromXapp, 1},
4153 Counter{cRestSubRespToXapp, 1},
4154 Counter{cSubReqToE2, 1},
4155 Counter{cSubRespFromE2, 1},
4156 Counter{cRestSubNotifToXapp, 1},
4157 Counter{cRestSubDelReqFromXapp, 1},
4158 Counter{cSubDelReqToE2, 1},
4159 Counter{cSubDelFailFromE2, 1},
4160 Counter{cRestSubDelRespToXapp, 1},
4164 var params *teststube2ap.RESTSubsReqParams = nil
4165 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4168 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4170 // E2t: Send receive SubsDelReq and send SubsDelFail
4171 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4172 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
4174 //Wait that subs is cleaned
4175 waitSubsCleanup(t, e2SubsId, 10)
4177 mainCtrl.VerifyCounterValues(t)
4178 mainCtrl.VerifyAllClean(t)
4181 //-----------------------------------------------------------------------------
4182 // TestRESTSubReqAndSubDelOkSameAction
4185 // +-------+ +-------+ +---------+ +---------+
4186 // | xapp2 | | xapp1 | | submgr | | e2term |
4187 // +-------+ +-------+ +---------+ +---------+
4189 // | | RESTSubReq1 | |
4190 // | |---------------->| |
4192 // | | RESTSubResp1 | |
4193 // | |<----------------| |
4196 // | | |------------->|
4198 // | | |<-------------|
4199 // | | RESTNotif1 | |
4200 // | |<----------------| |
4202 // | RESTSubReq2 | |
4203 // |------------------------------>| |
4205 // | RESTSubResp2 | |
4206 // |<------------------------------| |
4208 // | | RESTNotif2 | |
4209 // |<------------------------------| |
4211 // | | RESTSubDelReq1 | |
4212 // | |---------------->| |
4214 // | | RESTSubDelResp1 | |
4215 // | |<----------------| |
4217 // | RESTSubDelReq2 | |
4218 // |------------------------------>| |
4220 // | RESTSubDelResp2 | |
4221 // |<------------------------------| |
4223 // | | | SubDelReq2 |
4224 // | | |------------->|
4226 // | | | SubDelResp2 |
4227 // | | |<-------------|
4230 //-----------------------------------------------------------------------------
4231 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
4232 CaseBegin("TestRESTSubReqAndSubDelOkSameAction")
4234 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4235 Counter{cRestSubReqFromXapp, 2},
4236 Counter{cRestSubRespToXapp, 2},
4237 Counter{cSubReqToE2, 1},
4238 Counter{cSubRespFromE2, 1},
4239 Counter{cRestSubNotifToXapp, 2},
4240 Counter{cMergedSubscriptions, 1},
4241 Counter{cUnmergedSubscriptions, 1},
4242 Counter{cRestSubDelReqFromXapp, 2},
4243 Counter{cSubDelReqToE2, 1},
4244 Counter{cSubDelRespFromE2, 1},
4245 Counter{cRestSubDelRespToXapp, 2},
4249 var params *teststube2ap.RESTSubsReqParams = nil
4252 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4253 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4256 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4257 params.SetMeid("RAN_NAME_1")
4259 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4260 xappConn2.ExpectAnyNotification(t)
4261 waiter := rtmgrHttp.AllocNextSleep(10, true)
4262 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4263 waiter.WaitResult(t)
4264 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
4265 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
4266 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
4268 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
4271 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4274 deleteXapp2Subscription(t, &restSubId2)
4276 //Wait that subs is cleaned
4277 waitSubsCleanup(t, e2SubsId2, 10)
4278 mainCtrl.VerifyCounterValues(t)
4279 mainCtrl.VerifyAllClean(t)
4282 //-----------------------------------------------------------------------------
4283 // TestSubReqAndSubDelOkSameActionParallel
4286 // +-------+ +-------+ +---------+ +---------+
4287 // | xapp2 | | xapp1 | | submgr | | e2term |
4288 // +-------+ +-------+ +---------+ +---------+
4293 // | |------------->| |
4296 // | | |------------->|
4298 // |--------------------------->| |
4300 // | | |<-------------|
4302 // | |<-------------| |
4304 // | | |------------->|
4307 // | | |<-------------|
4309 // |<---------------------------| |
4311 // | | SubDelReq 1 | |
4312 // | |------------->| |
4314 // | | SubDelResp 1 | |
4315 // | |<-------------| |
4317 // | SubDelReq 2 | |
4318 // |--------------------------->| |
4320 // | | | SubDelReq 2 |
4321 // | | |------------->|
4323 // | | | SubDelReq 2 |
4324 // | | |------------->|
4326 // | SubDelResp 2 | |
4327 // |<---------------------------| |
4329 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
4330 CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel")
4332 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4333 Counter{cRestSubReqFromXapp, 2},
4334 Counter{cRestSubRespToXapp, 2},
4335 Counter{cSubReqToE2, 2},
4336 Counter{cSubRespFromE2, 2},
4337 Counter{cRestSubNotifToXapp, 2},
4338 Counter{cRestSubDelReqFromXapp, 2},
4339 Counter{cSubDelReqToE2, 2},
4340 Counter{cSubDelRespFromE2, 2},
4341 Counter{cRestSubDelRespToXapp, 2},
4344 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4345 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4346 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4348 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4349 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4351 xappConn1.ExpectRESTNotification(t, restSubId1)
4352 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4353 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4355 xappConn2.ExpectRESTNotification(t, restSubId2)
4356 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
4357 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
4358 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4361 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4362 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4363 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4364 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4367 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4368 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
4369 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
4371 waitSubsCleanup(t, e2SubsId2, 10)
4372 mainCtrl.VerifyCounterValues(t)
4373 mainCtrl.VerifyAllClean(t)
4376 //-----------------------------------------------------------------------------
4377 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
4380 // +-------+ +-------+ +---------+ +---------+
4381 // | xapp2 | | xapp1 | | submgr | | e2term |
4382 // +-------+ +-------+ +---------+ +---------+
4386 // | | RESTSubReq1 | |
4387 // | |---------------->| |
4389 // | | RESTSubResp1 | |
4390 // | |<----------------| |
4392 // | | |------------->|
4393 // | RESTSubReq2 | |
4394 // |------------------------------>| |
4396 // | RESTSubResp2 | |
4397 // |<------------------------------| |
4399 // | | |------------->|
4402 // | | | SubDelReq |
4403 // | | |------------->|
4405 // | | | SubDelResp |
4406 // | | |<-------------|
4407 // | | RESTNotif1 | |
4408 // | | unsuccess | |
4409 // | |<----------------| |
4411 // | | unsuccess | |
4412 // |<------------------------------| |
4414 // | | RESTSubDelReq1 | |
4415 // | |---------------->| |
4417 // | | RESTSubDelResp1 | |
4418 // | |<----------------| |
4420 // | RESTSubDelReq2 | |
4421 // |------------------------------>| |
4423 // | RESTSubDelResp2 | |
4424 // |<------------------------------| |
4426 //-----------------------------------------------------------------------------
4427 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
4428 CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
4430 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4431 Counter{cRestSubReqFromXapp, 2},
4432 Counter{cMergedSubscriptions, 1},
4433 Counter{cRestSubRespToXapp, 2},
4434 Counter{cSubReqToE2, 1},
4435 Counter{cSubReqTimerExpiry, 2},
4436 Counter{cSubReReqToE2, 1},
4437 Counter{cRestSubFailNotifToXapp, 2},
4438 Counter{cUnmergedSubscriptions, 1},
4439 Counter{cRestSubDelReqFromXapp, 2},
4440 Counter{cSubDelReqToE2, 1},
4441 Counter{cSubDelRespFromE2, 1},
4442 Counter{cRestSubDelRespToXapp, 2},
4444 const subReqCount int = 1
4447 params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4448 restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
4449 crereq1, _ := e2termConn1.RecvSubsReq(t)
4452 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4453 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4454 params2.SetMeid("RAN_NAME_1")
4455 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4456 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4458 //Req1 (retransmitted)
4459 e2termConn1.RecvSubsReq(t)
4461 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4463 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4464 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4466 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4467 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4468 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4469 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4472 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4475 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4477 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
4479 //Wait that subs is cleaned
4480 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4481 mainCtrl.VerifyCounterValues(t)
4482 mainCtrl.VerifyAllClean(t)
4485 //-----------------------------------------------------------------------------
4486 // TestRESTSubReqAndSubDelNokSameActionParallel
4489 // +-------+ +-------+ +---------+ +---------+
4490 // | xapp2 | | xapp1 | | submgr | | e2term |
4491 // +-------+ +-------+ +---------+ +---------+
4495 // | | RESTSubReq1 | |
4496 // | |---------------->| |
4498 // | | RESTSubResp1 | |
4499 // | |<----------------| |
4501 // | | |------------->|
4502 // | RESTSubReq2 | |
4503 // |------------------------------>| |
4505 // | RESTSubDelResp2 | |
4506 // |<------------------------------| |
4508 // | | |<-------------|
4510 // | | RESTNotif1 | |
4511 // | | unsuccess | |
4512 // | |<----------------| |
4514 // | | unsuccess | |
4515 // |<------------------------------| |
4517 // | | RESTSubDelReq1 | | There is no need for xApp to send delete for failed subscriptions but some xApp might do so.
4518 // | |---------------->| |
4520 // | | RESTSubDelResp1 | |
4521 // | |<----------------| |
4523 // | RESTSubDelReq2 | |
4524 // |------------------------------>| |
4526 // | RESTSubDelResp2 | |
4527 // |<------------------------------| |
4529 //-----------------------------------------------------------------------------
4530 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
4531 CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
4533 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4534 Counter{cRestSubReqFromXapp, 2},
4535 Counter{cMergedSubscriptions, 1},
4536 Counter{cRestSubRespToXapp, 2},
4537 Counter{cSubReqToE2, 1},
4538 Counter{cSubFailFromE2, 1},
4539 Counter{cRestSubFailNotifToXapp, 2},
4540 Counter{cUnmergedSubscriptions, 1},
4541 Counter{cRestSubDelReqFromXapp, 2},
4542 Counter{cRestSubDelRespToXapp, 2},
4545 const subReqCount int = 1
4548 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4549 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4550 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4553 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4554 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4555 params2.SetMeid("RAN_NAME_1")
4556 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4557 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4559 // E2t: send SubsFail (first)
4560 fparams1 := &teststube2ap.E2StubSubsFailParams{}
4561 fparams1.Set(crereq1)
4562 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
4564 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4565 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4566 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4567 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4568 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4571 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4574 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4576 //Wait that subs is cleaned
4577 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4578 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
4579 mainCtrl.VerifyCounterValues(t)
4580 mainCtrl.VerifyAllClean(t)
4583 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
4584 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4586 // Init counter check
4587 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4588 Counter{cRestSubReqFromXapp, 1},
4589 Counter{cRestSubRespToXapp, 1},
4590 Counter{cSubReqToE2, 1},
4591 Counter{cSubRespFromE2, 1},
4592 Counter{cRestSubNotifToXapp, 1},
4593 Counter{cRestSubDelReqFromXapp, 1},
4594 Counter{cSubDelReqToE2, 1},
4595 Counter{cSubDelRespFromE2, 1},
4596 Counter{cRestSubDelRespToXapp, 1},
4599 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4600 restSubId := xappConn1.SendRESTSubsReq(t, params)
4601 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
4603 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4604 xappConn1.ExpectRESTNotification(t, restSubId)
4605 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4606 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4607 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
4609 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4610 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4611 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4613 // Wait that subs is cleaned
4614 waitSubsCleanup(t, e2SubsId, 10)
4615 mainCtrl.VerifyCounterValues(t)
4616 mainCtrl.VerifyAllClean(t)
4619 //-----------------------------------------------------------------------------
4620 // TestRESTSubReqPolicyChangeAndSubDelOk
4623 // +-------+ +---------+ +---------+
4624 // | xapp | | submgr | | e2term |
4625 // +-------+ +---------+ +---------+
4628 // |---------------->| |
4630 // | RESTSubResp | |
4631 // |<----------------| |
4633 // | |------------->|
4636 // | |<-------------|
4639 // |<----------------| |
4642 // |---------------->| |
4644 // | RESTSubResp | |
4645 // |<----------------| |
4647 // | |------------->|
4650 // | |<-------------|
4653 // |<----------------| |
4655 // | RESTSubDelReq | |
4656 // |---------------->| |
4659 // | |------------->|
4662 // | |<-------------|
4664 // | RESTSubDelResp | |
4665 // |<----------------| |
4667 //-----------------------------------------------------------------------------
4668 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
4669 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4671 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4672 Counter{cRestSubReqFromXapp, 2},
4673 Counter{cRestSubRespToXapp, 2},
4674 Counter{cSubReqToE2, 2},
4675 Counter{cSubRespFromE2, 2},
4676 Counter{cRestSubNotifToXapp, 2},
4677 Counter{cRestSubDelReqFromXapp, 1},
4678 Counter{cSubDelReqToE2, 1},
4679 Counter{cSubDelRespFromE2, 1},
4680 Counter{cRestSubDelRespToXapp, 1},
4683 const subReqCount int = 1
4684 const e2Timeout int64 = 1
4685 const e2RetryCount int64 = 0
4686 const routingNeeded bool = true
4689 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4690 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4691 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4694 // GetRESTSubsReqPolicyParams sets some counters on tc side.
4696 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4697 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4698 params.SetSubscriptionID(&restSubId)
4699 params.SetTimeToWait("w200ms")
4700 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
4703 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4705 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4706 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4708 // Wait that subs is cleaned
4709 waitSubsCleanup(t, e2SubsId, 10)
4710 mainCtrl.VerifyCounterValues(t)
4711 mainCtrl.VerifyAllClean(t)
4714 //-----------------------------------------------------------------------------
4715 // TestRESTSubReqPolicyChangeNOk
4718 // +-------+ +---------+ +---------+
4719 // | xapp | | submgr | | e2term |
4720 // +-------+ +---------+ +---------+
4723 // |---------------->| |
4725 // | RESTSubResp | |
4726 // |<----------------| |
4728 // | |------------->|
4731 // | |<-------------|
4734 // |<----------------| |
4737 // |---------------->| |
4739 // | RESTSubUpdateFail(400 Bad request)
4741 // | RESTSubDelReq | |
4742 // |---------------->| |
4745 // | |------------->|
4748 // | |<-------------|
4750 // | RESTSubDelResp | |
4751 // |<----------------| |
4753 //-----------------------------------------------------------------------------
4754 func TestRESTSubReqPolicyChangeNOk(t *testing.T) {
4755 CaseBegin("TestRESTSubReqPolicyChangeNOk")
4757 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4758 Counter{cRestSubReqFromXapp, 2},
4759 Counter{cRestSubRespToXapp, 1},
4760 Counter{cSubReqToE2, 1},
4761 Counter{cSubRespFromE2, 1},
4762 Counter{cRestSubNotifToXapp, 1},
4763 Counter{cRestSubFailToXapp, 1},
4764 Counter{cRestSubDelReqFromXapp, 1},
4765 Counter{cSubDelReqToE2, 1},
4766 Counter{cSubDelRespFromE2, 1},
4767 Counter{cRestSubDelRespToXapp, 1},
4771 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4772 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4775 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4777 restSubIdUpd := strings.ToUpper(restSubId) // This makes RESTSubReq to fail
4778 params.SetSubscriptionID(&restSubIdUpd)
4779 params.SetTimeToWait("w200ms")
4781 restSubId2 := xappConn1.SendRESTSubsReq(t, params)
4782 assert.Equal(t, restSubId2, "")
4785 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4787 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4788 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4790 // Wait that subs is cleaned
4791 waitSubsCleanup(t, e2SubsId, 10)
4792 mainCtrl.VerifyCounterValues(t)
4793 mainCtrl.VerifyAllClean(t)
4796 //-----------------------------------------------------------------------------
4797 // TestRESTSubReqAndSubDelOkTwoE2termParallel
4800 // +-------+ +---------+ +---------+ +---------+
4801 // | xapp | | submgr | | e2term1 | | e2term2 |
4802 // +-------+ +---------+ +---------+ +---------+
4806 // | RESTSubReq1 | | |
4807 // |---------------->| | |
4809 // | RESTSubResp1 | | |
4810 // |<----------------| | |
4812 // | |------------->| |
4814 // | RESTSubReq2 | | |
4815 // |---------------->| | |
4817 // | RESTSubResp2 | | |
4818 // |<----------------| | |
4820 // | |---------------------------->|
4823 // | |<-------------| |
4824 // | RESTNotif1 | | |
4825 // |<----------------| | |
4827 // | |<----------------------------|
4828 // | RESTNotif2 | | |
4829 // |<----------------| | |
4831 // | [SUBS 1 DELETE] | |
4833 // | [SUBS 2 DELETE] | |
4836 //-----------------------------------------------------------------------------
4837 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
4838 CaseBegin("TestRESTSubReqAndSubDelOkTwoE2termParallel")
4840 // Init counter check
4841 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4842 Counter{cRestSubReqFromXapp, 2},
4843 Counter{cRestSubRespToXapp, 2},
4844 Counter{cSubReqToE2, 2},
4845 Counter{cSubRespFromE2, 2},
4846 Counter{cRestSubNotifToXapp, 2},
4847 Counter{cRestSubDelReqFromXapp, 2},
4848 Counter{cSubDelReqToE2, 2},
4849 Counter{cSubDelRespFromE2, 2},
4850 Counter{cRestSubDelRespToXapp, 2},
4853 const subReqCount int = 1
4856 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4857 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4858 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4861 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4862 params.SetMeid("RAN_NAME_11")
4863 // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
4864 // would not work as notification would not be received
4865 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4866 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
4869 xappConn1.ExpectRESTNotification(t, restSubId1)
4870 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4871 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4872 xapp.Logger.Debug("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
4875 xappConn2.ExpectRESTNotification(t, restSubId2)
4876 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
4877 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4878 xapp.Logger.Debug("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
4881 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4882 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4883 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4885 // Wait that subs is cleaned
4886 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4889 xappConn1.SendRESTSubsDelReq(t, &restSubId2)
4890 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
4891 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
4893 // Wait that subs is cleaned
4894 waitSubsCleanup(t, e2SubsId2, 10)
4896 mainCtrl.VerifyCounterValues(t)
4897 mainCtrl.VerifyAllClean(t)
4900 //-----------------------------------------------------------------------------
4901 // TestRESTSubReqAsn1EncodeFail
4903 // In this case submgr send RICSubscriptionDeleteRequest after encode failure which should not happen!
4905 // +-------+ +---------+ +---------+
4906 // | xapp | | submgr | | e2term |
4907 // +-------+ +---------+ +---------+
4910 // |---------------->| |
4912 // | RESTSubResp | |
4913 // |<----------------| |
4914 // | RESTSubDelReq | |
4915 // |---------------->| |
4916 // | RESTSubDelResp | |
4918 // |<----------------| |
4921 //-----------------------------------------------------------------------------
4922 func TestRESTSubReqAsn1EncodeFail(t *testing.T) {
4923 CaseBegin("TestRESTSubReqAsn1EncodeFail")
4925 xapp.Logger.Debug("Xapp-frame, v0.8.1 sufficient REST API validation")
4929 //-----------------------------------------------------------------------------
4930 // TestRESTSubReqInsertAndSubDelOk
4933 // +-------+ +---------+ +---------+
4934 // | xapp | | submgr | | e2term |
4935 // +-------+ +---------+ +---------+
4938 // |---------------->| |
4940 // | RESTSubResp | |
4941 // |<----------------| |
4944 // | |------------->|
4947 // | |<-------------|
4949 // |<----------------| |
4952 // | RESTSubDelReq | |
4953 // |---------------->| |
4956 // | |------------->|
4959 // | |<-------------|
4961 // | RESTSubDelResp| |
4962 // |<----------------| |
4964 //-----------------------------------------------------------------------------
4965 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
4966 CaseBegin("TestRESTInsertSubReqAndSubDelOk")
4968 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4969 Counter{cRestSubReqFromXapp, 1},
4970 Counter{cRestSubRespToXapp, 1},
4971 Counter{cSubReqToE2, 1},
4972 Counter{cSubRespFromE2, 1},
4973 Counter{cRestSubNotifToXapp, 1},
4974 Counter{cRestSubDelReqFromXapp, 1},
4975 Counter{cSubDelReqToE2, 1},
4976 Counter{cSubDelRespFromE2, 1},
4977 Counter{cRestSubDelRespToXapp, 1},
4980 const subReqCount int = 1
4982 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4983 params.SetSubActionTypes("insert")
4986 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4989 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4991 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4992 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4994 // Wait that subs is cleaned
4995 waitSubsCleanup(t, e2SubsId, 10)
4996 mainCtrl.VerifyCounterValues(t)
4997 mainCtrl.VerifyAllClean(t)
5000 //-----------------------------------------------------------------------------
5001 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
5004 // +-------+ +---------+ +---------+
5005 // | xapp | | submgr | | e2term |
5006 // +-------+ +---------+ +---------+
5009 // |------------->| |
5011 // | RESTSubResp | |
5012 // |<-------------| |
5014 // | |------------->|
5019 // | Submgr restart |
5023 // | |------------->|
5026 // | |<-------------|
5030 // |<-------------| |
5032 // | RESTSubDelReq| |
5033 // |------------->| |
5035 // |RESTSubDelResp| |
5036 // |<-------------| |
5038 //-----------------------------------------------------------------------------
5039 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
5040 CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle")
5042 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5043 Counter{cRestSubReqFromXapp, 1},
5044 Counter{cRestSubRespToXapp, 1},
5045 Counter{cSubReqToE2, 1},
5046 Counter{cSubDelReqFromXapp, 1},
5047 Counter{cSubDelReqToE2, 1},
5048 Counter{cSubDelRespFromE2, 1},
5049 Counter{cRestSubDelReqFromXapp, 1},
5050 Counter{cRestSubDelRespToXapp, 1},
5053 const subReqCount int = 1
5055 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5058 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
5059 restSubId := xappConn1.SendRESTSubsReq(t, params)
5060 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5062 e2termConn1.RecvSubsReq(t)
5064 mainCtrl.SetResetTestFlag(t, false)
5066 mainCtrl.SimulateRestart(t)
5067 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5069 // Deleletion of uncompleted subscription
5070 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5071 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5074 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5076 xappConn1.TestMsgChanEmpty(t)
5077 e2termConn1.TestMsgChanEmpty(t)
5078 mainCtrl.wait_registry_empty(t, 10)
5080 mainCtrl.VerifyCounterValues(t)
5081 mainCtrl.VerifyAllClean(t)
5084 //-----------------------------------------------------------------------------
5085 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
5088 // +-------+ +---------+ +---------+
5089 // | xapp | | submgr | | e2term |
5090 // +-------+ +---------+ +---------+
5093 // |---------------->| |
5095 // | RESTSubResp | |
5096 // |<----------------| |
5098 // | |------------->|
5101 // | |<-------------|
5104 // |<----------------| |
5107 // | Submgr restart |
5109 // | RESTSubDelReq | |
5110 // |---------------->| |
5113 // | |------------->|
5116 // | |<-------------|
5118 // | RESTSubDelResp | |
5119 // |<----------------| |
5121 //-----------------------------------------------------------------------------
5123 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
5124 CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle")
5126 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5127 Counter{cRestSubReqFromXapp, 1},
5128 Counter{cRestSubRespToXapp, 1},
5129 Counter{cSubReqToE2, 1},
5130 Counter{cSubRespFromE2, 1},
5131 Counter{cRestSubNotifToXapp, 1},
5132 Counter{cRestSubDelReqFromXapp, 1},
5133 Counter{cSubDelReqToE2, 1},
5134 Counter{cSubDelRespFromE2, 1},
5135 Counter{cRestSubDelRespToXapp, 1},
5138 // Create subscription
5139 var params *teststube2ap.RESTSubsReqParams = nil
5140 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5141 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5143 // Check subscription
5144 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5146 mainCtrl.SimulateRestart(t)
5147 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5149 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5150 // That needs to be completed before successful subscription query is possible
5151 <-time.After(time.Second * 1)
5153 // Check subscription
5154 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5156 // Delete subscription
5157 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
5159 //Wait that subs is cleaned
5160 waitSubsCleanup(t, e2SubsId, 10)
5162 mainCtrl.VerifyCounterValues(t)
5163 mainCtrl.VerifyAllClean(t)
5166 //-----------------------------------------------------------------------------
5167 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
5170 // +-------+ +-------+ +---------+ +---------+
5171 // | xapp2 | | xapp1 | | submgr | | e2term |
5172 // +-------+ +-------+ +---------+ +---------+
5174 // | | RESTSubReq1 | |
5175 // | |---------------->| |
5177 // | | RESTSubResp1 | |
5178 // | |<----------------| |
5181 // | | |------------->|
5183 // | | |<-------------|
5184 // | | RESTNotif1 | |
5185 // | |<----------------| |
5187 // | RESTSubReq2 | |
5188 // |------------------------------>| |
5190 // | RESTSubResp2 | |
5191 // |<------------------------------| |
5193 // | | RESTNotif2 | |
5194 // |<------------------------------| |
5196 // | | Submgr restart |
5198 // | | RESTSubDelReq1 | |
5199 // | |---------------->| |
5201 // | | RESTSubDelResp1 | |
5202 // | |<----------------| |
5204 // | | Submgr restart |
5206 // | RESTSubDelReq2 | |
5207 // |------------------------------>| |
5209 // | RESTSubDelResp2 | |
5210 // |<------------------------------| |
5212 // | | | SubDelReq2 |
5213 // | | |------------->|
5215 // | | | SubDelResp2 |
5216 // | | |<-------------|
5219 //-----------------------------------------------------------------------------
5220 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
5221 CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
5223 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5224 Counter{cRestSubReqFromXapp, 2},
5225 Counter{cRestSubRespToXapp, 2},
5226 Counter{cSubReqToE2, 1},
5227 Counter{cSubRespFromE2, 1},
5228 Counter{cRestSubNotifToXapp, 2},
5229 Counter{cMergedSubscriptions, 1},
5230 Counter{cUnmergedSubscriptions, 1},
5231 Counter{cRestSubDelReqFromXapp, 2},
5232 Counter{cSubDelReqToE2, 1},
5233 Counter{cSubDelRespFromE2, 1},
5234 Counter{cRestSubDelRespToXapp, 2},
5237 // Create subscription 1
5238 var params *teststube2ap.RESTSubsReqParams = nil
5239 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5240 xapp.Logger.Debug("Send REST subscriber request for subscriber 1 : %v", restSubId1)
5242 // Create subscription 2 with same action
5243 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5244 params.SetMeid("RAN_NAME_1")
5245 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
5246 xappConn2.ExpectAnyNotification(t)
5247 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5248 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5249 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
5250 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
5252 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
5254 mainCtrl.SimulateRestart(t)
5255 xapp.Logger.Debug("mainCtrl.SimulateRestart done 1")
5257 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5258 // That needs to be completed before successful subscription delete is possible
5259 <-time.After(time.Second * 1)
5261 // Delete subscription 1, and wait until it has removed the first endpoint
5262 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5263 mainCtrl.WaitRESTSubscriptionDelete(restSubId1)
5264 // Above wait does not work correctly anymore as this delay makes this test case work
5266 mainCtrl.SimulateRestart(t)
5267 xapp.Logger.Debug("mainCtrl.SimulateRestart done 2")
5269 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5270 // That needs to be completed before successful subscription query is possible
5271 <-time.After(time.Second * 1)
5273 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
5275 // Delete subscription 2
5276 deleteXapp2Subscription(t, &restSubId2)
5278 //Wait that subs is cleaned
5279 waitSubsCleanup(t, e2SubsId2, 10)
5281 mainCtrl.VerifyCounterValues(t)
5282 mainCtrl.VerifyAllClean(t)
5285 //-----------------------------------------------------------------------------
5286 // TestRESTReportSubReqAndSubDelOk
5289 // +-------+ +---------+ +---------+
5290 // | xapp | | submgr | | e2term |
5291 // +-------+ +---------+ +---------+
5294 // |---------------->| |
5296 // | RESTSubResp | |
5297 // |<----------------| |
5300 // | |------------->|
5303 // | |<-------------|
5305 // |<----------------| |
5307 // | |------------->|
5310 // | |<-------------|
5312 // |<----------------| |
5316 // | RESTSubDelReq | |
5317 // |---------------->| |
5320 // | |------------->|
5323 // | |<-------------|
5325 // | RESTSubDelResp| |
5326 // |<----------------| |
5328 //-----------------------------------------------------------------------------
5330 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
5331 CaseBegin("TestRESTReportSubReqAndSubDelOk")
5332 const subReqCount int = 1
5334 RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
5337 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5338 xapp.Logger.Debug("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
5341 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5342 restSubId := xappConn1.SendRESTSubsReq(t, params)
5344 var e2SubsId []uint32
5345 for i := 0; i < subReqCount; i++ {
5346 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5347 xappConn1.ExpectRESTNotification(t, restSubId)
5349 e2termConn1.SendSubsResp(t, crereq, cremsg)
5350 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5351 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5352 e2SubsId = append(e2SubsId, instanceId)
5353 resp, _ := xapp.Subscription.QuerySubscriptions()
5354 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
5355 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
5356 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
5361 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5363 for i := 0; i < subReqCount; i++ {
5364 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5365 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5368 // Wait that subs is cleaned
5369 for i := 0; i < subReqCount; i++ {
5370 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5373 xappConn1.TestMsgChanEmpty(t)
5374 e2termConn1.TestMsgChanEmpty(t)
5375 mainCtrl.wait_registry_empty(t, 10)
5376 mainCtrl.VerifyAllClean(t)
5380 func TestRESTPolicySubReqAndSubDelOk(t *testing.T) { was in comments already
5381 CaseBegin("TestRESTPolicySubReqAndSubDelOk")
5385 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5389 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5392 func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5393 xapp.Logger.Debug("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
5396 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5397 restSubId := xappConn1.SendRESTSubsReq(t, params)
5399 var e2SubsId []uint32
5400 for i := 0; i < subReqCount; i++ {
5401 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5402 xappConn1.ExpectRESTNotification(t, restSubId)
5403 e2termConn1.SendSubsResp(t, crereq, cremsg)
5404 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5405 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5406 e2SubsId = append(e2SubsId, instanceId)
5410 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5412 for i := 0; i < subReqCount; i++ {
5413 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5414 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5417 // Wait that subs is cleaned
5418 for i := 0; i < subReqCount; i++ {
5419 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5421 xappConn1.TestMsgChanEmpty(t)
5422 e2termConn1.TestMsgChanEmpty(t)
5423 mainCtrl.wait_registry_empty(t, 10)
5424 mainCtrl.VerifyAllClean(t)
5427 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
5429 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5430 Counter{cRestSubReqFromXapp, 1},
5431 Counter{cRestSubRespToXapp, 1},
5432 Counter{cSubReqToE2, 2},
5433 Counter{cSubRespFromE2, 2},
5434 Counter{cRestSubNotifToXapp, 2},
5435 Counter{cRestSubDelReqFromXapp, 1},
5436 Counter{cSubDelReqToE2, 2},
5437 Counter{cSubDelRespFromE2, 2},
5438 Counter{cRestSubDelRespToXapp, 1},
5441 const subReqCount int = 2
5444 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5445 restSubId := xappConn1.SendRESTSubsReq(t, params)
5446 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5448 assert.Equal(t, len(e2SubsIds), 2)
5451 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5452 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5454 xappConn1.TestMsgChanEmpty(t)
5455 e2termConn1.TestMsgChanEmpty(t)
5456 mainCtrl.wait_registry_empty(t, 10)
5458 mainCtrl.VerifyCounterValues(t)
5459 mainCtrl.VerifyAllClean(t)
5461 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
5463 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5464 Counter{cRestSubReqFromXapp, 1},
5465 Counter{cRestSubRespToXapp, 1},
5466 Counter{cSubReqToE2, 19},
5467 Counter{cSubRespFromE2, 19},
5468 Counter{cRestSubNotifToXapp, 19},
5469 Counter{cRestSubDelReqFromXapp, 1},
5470 Counter{cSubDelReqToE2, 19},
5471 Counter{cSubDelRespFromE2, 19},
5472 Counter{cRestSubDelRespToXapp, 1},
5475 const subReqCount int = 19
5477 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5478 restSubId := xappConn1.SendRESTSubsReq(t, params)
5479 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5481 assert.Equal(t, len(e2SubsIds), 19)
5483 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5484 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5486 xappConn1.TestMsgChanEmpty(t)
5487 e2termConn1.TestMsgChanEmpty(t)
5488 mainCtrl.wait_registry_empty(t, 10)
5490 mainCtrl.VerifyCounterValues(t)
5491 mainCtrl.VerifyAllClean(t)
5494 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
5498 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5499 Counter{cRestSubReqFromXapp, 1},
5500 Counter{cRestSubRespToXapp, 1},
5501 Counter{cSubReqToE2, uint64(subReqCount)},
5502 Counter{cSubRespFromE2, uint64(subReqCount)},
5503 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5504 Counter{cRestSubDelReqFromXapp, 1},
5505 Counter{cSubDelReqToE2, uint64(subReqCount)},
5506 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5507 Counter{cRestSubDelRespToXapp, 1},
5511 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5512 restSubId := xappConn1.SendRESTSubsReq(t, params)
5513 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5515 assert.Equal(t, len(e2SubsIds), subReqCount)
5518 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5519 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5521 xappConn1.TestMsgChanEmpty(t)
5522 e2termConn1.TestMsgChanEmpty(t)
5523 mainCtrl.wait_registry_empty(t, 10)
5525 mainCtrl.VerifyCounterValues(t)
5526 mainCtrl.VerifyAllClean(t)
5529 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
5533 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5534 Counter{cRestSubReqFromXapp, 1},
5535 Counter{cRestSubRespToXapp, 1},
5536 Counter{cSubReqToE2, uint64(subReqCount)},
5537 Counter{cSubRespFromE2, uint64(subReqCount)},
5538 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5539 Counter{cRestSubDelReqFromXapp, 1},
5540 Counter{cSubDelReqToE2, uint64(subReqCount)},
5541 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5542 Counter{cRestSubDelRespToXapp, 1},
5546 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5547 restSubId := xappConn1.SendRESTSubsReq(t, params)
5548 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5550 assert.Equal(t, len(e2SubsIds), subReqCount)
5553 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5554 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5556 xappConn1.TestMsgChanEmpty(t)
5557 e2termConn1.TestMsgChanEmpty(t)
5558 mainCtrl.wait_registry_empty(t, 10)
5560 mainCtrl.VerifyCounterValues(t)
5561 mainCtrl.VerifyAllClean(t)
5564 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
5568 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5569 Counter{cRestSubReqFromXapp, 1},
5570 Counter{cRestSubRespToXapp, 1},
5571 Counter{cSubReqToE2, uint64(subReqCount)},
5572 Counter{cSubRespFromE2, uint64(subReqCount)},
5573 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5574 Counter{cRestSubDelReqFromXapp, 1},
5575 Counter{cSubDelReqToE2, uint64(subReqCount)},
5576 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5577 Counter{cRestSubDelRespToXapp, 1},
5581 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5582 restSubId := xappConn1.SendRESTSubsReq(t, params)
5583 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5585 assert.Equal(t, len(e2SubsIds), subReqCount)
5588 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5589 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5591 xappConn1.TestMsgChanEmpty(t)
5592 e2termConn1.TestMsgChanEmpty(t)
5593 mainCtrl.wait_registry_empty(t, 10)
5595 mainCtrl.VerifyCounterValues(t)
5596 mainCtrl.VerifyAllClean(t)
5599 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
5600 CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
5602 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5603 Counter{cRestSubReqFromXapp, 2},
5604 Counter{cRestSubRespToXapp, 2},
5605 Counter{cSubReqToE2, 2},
5606 Counter{cSubRespFromE2, 2},
5607 Counter{cRestSubNotifToXapp, 2},
5608 Counter{cRestSubDelReqFromXapp, 2},
5609 Counter{cSubDelReqToE2, 2},
5610 Counter{cSubDelRespFromE2, 2},
5611 Counter{cRestSubDelRespToXapp, 2},
5615 var params *teststube2ap.RESTSubsReqParams = nil
5618 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5619 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5621 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5624 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5625 params.SetMeid("RAN_NAME_1")
5626 eventTriggerDefinition := []int64{1234, 1}
5627 params.SetSubEventTriggerDefinition(eventTriggerDefinition)
5629 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5630 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5631 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5632 xappConn2.ExpectRESTNotification(t, restSubId2)
5633 e2termConn1.SendSubsResp(t, crereq, cremsg)
5634 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5636 deleteXapp1Subscription(t, &restSubId1)
5637 deleteXapp2Subscription(t, &restSubId2)
5639 waitSubsCleanup(t, e2SubsId1, 10)
5640 waitSubsCleanup(t, e2SubsId2, 10)
5642 mainCtrl.VerifyCounterValues(t)
5643 mainCtrl.VerifyAllClean(t)
5646 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
5647 CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
5649 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5650 Counter{cRestSubReqFromXapp, 2},
5651 Counter{cRestSubRespToXapp, 2},
5652 Counter{cSubReqToE2, 2},
5653 Counter{cSubRespFromE2, 2},
5654 Counter{cRestSubNotifToXapp, 2},
5655 Counter{cRestSubDelReqFromXapp, 2},
5656 Counter{cSubDelReqToE2, 2},
5657 Counter{cSubDelRespFromE2, 2},
5658 Counter{cRestSubDelRespToXapp, 2},
5662 var params *teststube2ap.RESTSubsReqParams = nil
5665 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5666 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5668 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5671 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5672 params.SetMeid("RAN_NAME_1")
5674 actionId := int64(1)
5675 actionType := "report"
5676 actionDefinition := []int64{5678, 1}
5677 subsequestActionType := "continue"
5678 timeToWait := "w10ms"
5679 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
5681 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5682 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5683 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5684 xappConn2.ExpectRESTNotification(t, restSubId2)
5685 e2termConn1.SendSubsResp(t, crereq, cremsg)
5686 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5688 deleteXapp1Subscription(t, &restSubId1)
5689 deleteXapp2Subscription(t, &restSubId2)
5691 waitSubsCleanup(t, e2SubsId1, 10)
5692 waitSubsCleanup(t, e2SubsId2, 10)
5694 mainCtrl.VerifyCounterValues(t)
5695 mainCtrl.VerifyAllClean(t)
5698 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
5699 CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
5701 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5702 Counter{cRestSubReqFromXapp, 2},
5703 Counter{cRestSubRespToXapp, 2},
5704 Counter{cSubReqToE2, 2},
5705 Counter{cSubRespFromE2, 2},
5706 Counter{cRestSubNotifToXapp, 2},
5707 Counter{cRestSubDelReqFromXapp, 2},
5708 Counter{cSubDelReqToE2, 2},
5709 Counter{cSubDelRespFromE2, 2},
5710 Counter{cRestSubDelRespToXapp, 2},
5714 var params *teststube2ap.RESTSubsReqParams = nil
5717 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5718 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5720 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5723 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5724 params.SetMeid("RAN_NAME_1")
5725 params.SetSubActionIDs(int64(2))
5727 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5728 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5729 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5730 xappConn2.ExpectRESTNotification(t, restSubId2)
5731 e2termConn1.SendSubsResp(t, crereq, cremsg)
5732 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5734 deleteXapp1Subscription(t, &restSubId1)
5735 deleteXapp2Subscription(t, &restSubId2)
5737 waitSubsCleanup(t, e2SubsId1, 10)
5738 waitSubsCleanup(t, e2SubsId2, 10)
5740 mainCtrl.VerifyCounterValues(t)
5741 mainCtrl.VerifyAllClean(t)
5744 func TestRESTSubReqDiffActionType(t *testing.T) {
5745 CaseBegin("TestRESTSubReqDiffActionType")
5747 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5748 Counter{cRestSubReqFromXapp, 2},
5749 Counter{cRestSubRespToXapp, 2},
5750 Counter{cSubReqToE2, 2},
5751 Counter{cSubRespFromE2, 2},
5752 Counter{cRestSubNotifToXapp, 2},
5753 Counter{cRestSubDelReqFromXapp, 2},
5754 Counter{cSubDelReqToE2, 2},
5755 Counter{cSubDelRespFromE2, 2},
5756 Counter{cRestSubDelRespToXapp, 2},
5759 const e2Timeout int64 = 2
5760 const e2RetryCount int64 = 2
5761 const routingNeeded bool = true
5764 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5765 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5768 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5769 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5771 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5774 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5775 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5776 params.SetMeid("RAN_NAME_1")
5778 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5779 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5780 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5781 xappConn2.ExpectRESTNotification(t, restSubId2)
5782 e2termConn1.SendSubsResp(t, crereq, cremsg)
5783 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5785 deleteXapp1Subscription(t, &restSubId1)
5786 deleteXapp2Subscription(t, &restSubId2)
5788 waitSubsCleanup(t, e2SubsId1, 10)
5789 waitSubsCleanup(t, e2SubsId2, 10)
5791 mainCtrl.VerifyCounterValues(t)
5792 mainCtrl.VerifyAllClean(t)
5795 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
5796 CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
5798 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5799 Counter{cRestSubReqFromXapp, 2},
5800 Counter{cRestSubRespToXapp, 2},
5801 Counter{cSubReqToE2, 2},
5802 Counter{cSubRespFromE2, 2},
5803 Counter{cRestSubNotifToXapp, 2},
5804 Counter{cRestSubDelReqFromXapp, 2},
5805 Counter{cSubDelReqToE2, 2},
5806 Counter{cSubDelRespFromE2, 2},
5807 Counter{cRestSubDelRespToXapp, 2},
5810 const e2Timeout int64 = 2
5811 const e2RetryCount int64 = 2
5812 const routingNeeded bool = true
5815 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5816 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5819 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5820 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5822 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5825 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
5826 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5827 params.SetMeid("RAN_NAME_1")
5829 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5830 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5831 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5832 xappConn2.ExpectRESTNotification(t, restSubId2)
5833 e2termConn1.SendSubsResp(t, crereq, cremsg)
5834 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5836 deleteXapp1Subscription(t, &restSubId1)
5837 deleteXapp2Subscription(t, &restSubId2)
5839 waitSubsCleanup(t, e2SubsId1, 10)
5840 waitSubsCleanup(t, e2SubsId2, 10)
5842 mainCtrl.VerifyCounterValues(t)
5843 mainCtrl.VerifyAllClean(t)
5846 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
5847 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
5849 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5850 Counter{cRestSubReqFromXapp, 2},
5851 Counter{cRestSubRespToXapp, 2},
5852 Counter{cSubReqToE2, 2},
5853 Counter{cSubRespFromE2, 2},
5854 Counter{cRestSubNotifToXapp, 2},
5855 Counter{cRestSubDelReqFromXapp, 2},
5856 Counter{cSubDelReqToE2, 2},
5857 Counter{cSubDelRespFromE2, 2},
5858 Counter{cRestSubDelRespToXapp, 2},
5862 var params *teststube2ap.RESTSubsReqParams = nil
5865 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5866 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5868 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5871 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5872 params.SetMeid("RAN_NAME_1")
5873 actionDefinition := []int64{5678, 1}
5874 params.SetSubActionDefinition(actionDefinition)
5876 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5877 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5878 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5879 xappConn2.ExpectRESTNotification(t, restSubId2)
5880 e2termConn1.SendSubsResp(t, crereq, cremsg)
5881 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5883 deleteXapp1Subscription(t, &restSubId1)
5884 deleteXapp2Subscription(t, &restSubId2)
5886 waitSubsCleanup(t, e2SubsId1, 10)
5887 waitSubsCleanup(t, e2SubsId2, 10)
5889 mainCtrl.VerifyCounterValues(t)
5890 mainCtrl.VerifyAllClean(t)
5893 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
5894 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
5896 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5897 Counter{cRestSubReqFromXapp, 2},
5898 Counter{cRestSubRespToXapp, 2},
5899 Counter{cSubReqToE2, 2},
5900 Counter{cSubRespFromE2, 2},
5901 Counter{cRestSubNotifToXapp, 2},
5902 Counter{cRestSubDelReqFromXapp, 2},
5903 Counter{cSubDelReqToE2, 2},
5904 Counter{cSubDelRespFromE2, 2},
5905 Counter{cRestSubDelRespToXapp, 2},
5909 var params *teststube2ap.RESTSubsReqParams = nil
5912 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5913 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5915 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5918 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5919 params.SetMeid("RAN_NAME_1")
5920 actionDefinition := []int64{56782}
5921 params.SetSubActionDefinition(actionDefinition)
5923 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5924 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5925 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5926 xappConn2.ExpectRESTNotification(t, restSubId2)
5927 e2termConn1.SendSubsResp(t, crereq, cremsg)
5928 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5930 deleteXapp1Subscription(t, &restSubId1)
5931 deleteXapp2Subscription(t, &restSubId2)
5933 waitSubsCleanup(t, e2SubsId1, 10)
5934 waitSubsCleanup(t, e2SubsId2, 10)
5936 mainCtrl.VerifyCounterValues(t)
5937 mainCtrl.VerifyAllClean(t)
5940 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
5941 CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
5943 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5944 Counter{cRestSubReqFromXapp, 2},
5945 Counter{cRestSubRespToXapp, 2},
5946 Counter{cSubReqToE2, 2},
5947 Counter{cSubRespFromE2, 2},
5948 Counter{cRestSubNotifToXapp, 2},
5949 Counter{cRestSubDelReqFromXapp, 2},
5950 Counter{cSubDelReqToE2, 2},
5951 Counter{cSubDelRespFromE2, 2},
5952 Counter{cRestSubDelRespToXapp, 2},
5956 var params *teststube2ap.RESTSubsReqParams = nil
5959 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5960 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5962 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5965 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5966 params.SetMeid("RAN_NAME_1")
5967 params.SetTimeToWait("w200ms")
5968 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5969 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5970 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5971 xappConn2.ExpectRESTNotification(t, restSubId2)
5972 e2termConn1.SendSubsResp(t, crereq, cremsg)
5973 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5975 deleteXapp1Subscription(t, &restSubId1)
5976 deleteXapp2Subscription(t, &restSubId2)
5978 waitSubsCleanup(t, e2SubsId1, 10)
5979 waitSubsCleanup(t, e2SubsId2, 10)
5981 mainCtrl.VerifyCounterValues(t)
5982 mainCtrl.VerifyAllClean(t)
5985 //-----------------------------------------------------------------------------
5986 // TestRESTUnpackSubscriptionResponseDecodeFail
5989 // +-------+ +---------+ +---------+
5990 // | xapp | | submgr | | e2term |
5991 // +-------+ +---------+ +---------+
5994 // |---------------->| |
5996 // | RESTSubResp | |
5997 // |<----------------| |
6000 // | |------------->|
6002 // | | SubResp | ASN.1 decode fails
6003 // | |<-------------|
6006 // | |------------->|
6008 // | | SubFail | Duplicated action
6009 // | |<-------------|
6010 // | RESTNotif (fail)| |
6011 // |<----------------| |
6014 //-----------------------------------------------------------------------------
6016 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
6017 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
6018 const subReqCount int = 1
6021 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6022 restSubId := xappConn1.SendRESTSubsReq(t, params)
6024 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6025 // Decode of this response fails which will result resending original request
6026 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
6028 _, cremsg = e2termConn1.RecvSubsReq(t)
6030 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6032 // Subscription already created in E2 Node.
6033 fparams := &teststube2ap.E2StubSubsFailParams{}
6035 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6036 e2termConn1.SendSubsFail(t, fparams, cremsg)
6038 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6039 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6041 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6043 // Wait that subs is cleaned
6044 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6046 xappConn1.TestMsgChanEmpty(t)
6047 e2termConn1.TestMsgChanEmpty(t)
6048 mainCtrl.wait_registry_empty(t, 10)
6049 mainCtrl.VerifyAllClean(t)
6052 //-----------------------------------------------------------------------------
6053 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
6056 // +-------+ +---------+ +---------+
6057 // | xapp | | submgr | | e2term |
6058 // +-------+ +---------+ +---------+
6061 // |---------------->| |
6063 // | RESTSubResp | |
6064 // |<----------------| |
6067 // | |------------->|
6069 // | | SubResp | Unknown instanceId
6070 // | |<-------------|
6073 // | |------------->|
6075 // | | SubFail | Duplicated action
6076 // | |<-------------|
6077 // | RESTNotif (fail)| |
6078 // |<----------------| |
6080 // | |------------->|
6083 // | |<-------------|
6085 //-----------------------------------------------------------------------------
6087 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
6088 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
6089 const subReqCount int = 1
6092 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6093 restSubId := xappConn1.SendRESTSubsReq(t, params)
6095 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6097 // Unknown instanceId in this response which will result resending original request
6098 orgInstanceId := crereq.RequestId.InstanceId
6099 crereq.RequestId.InstanceId = 0
6100 e2termConn1.SendSubsResp(t, crereq, cremsg)
6102 _, cremsg = e2termConn1.RecvSubsReq(t)
6104 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6106 // Subscription already created in E2 Node.
6107 fparams := &teststube2ap.E2StubSubsFailParams{}
6109 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6110 e2termConn1.SendSubsFail(t, fparams, cremsg)
6112 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6113 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6115 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6116 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6118 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6120 // Wait that subs is cleaned
6121 mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
6123 xappConn1.TestMsgChanEmpty(t)
6124 e2termConn1.TestMsgChanEmpty(t)
6125 mainCtrl.wait_registry_empty(t, 10)
6126 mainCtrl.VerifyAllClean(t)
6129 //-----------------------------------------------------------------------------
6130 // TestRESTUnpackSubscriptionResponseNoTransaction
6133 // +-------+ +---------+ +---------+
6134 // | xapp | | submgr | | e2term |
6135 // +-------+ +---------+ +---------+
6138 // |---------------->| |
6140 // | RESTSubResp | |
6141 // |<----------------| |
6144 // | |------------->|
6146 // | | SubResp | No transaction for the response
6147 // | |<-------------|
6150 // | |------------->|
6152 // | | SubFail | Duplicated action
6153 // | |<-------------|
6154 // | RESTNotif (fail)| |
6155 // |<----------------| |
6157 // | |------------->|
6160 // | |<-------------|
6163 // | |------------->|
6166 // | |<-------------|
6168 //-----------------------------------------------------------------------------
6169 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
6170 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
6171 const subReqCount int = 1
6174 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6175 restSubId := xappConn1.SendRESTSubsReq(t, params)
6177 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6179 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6180 // No transaction exist for this response which will result resending original request
6181 e2termConn1.SendSubsResp(t, crereq, cremsg)
6183 _, cremsg = e2termConn1.RecvSubsReq(t)
6185 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6187 // Subscription already created in E2 Node.
6188 fparams := &teststube2ap.E2StubSubsFailParams{}
6190 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6191 e2termConn1.SendSubsFail(t, fparams, cremsg)
6193 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6194 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6196 // Resending happens because there no transaction
6197 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6198 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6200 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6201 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6203 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6205 // Wait that subs is cleaned
6206 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6208 xappConn1.TestMsgChanEmpty(t)
6209 e2termConn1.TestMsgChanEmpty(t)
6210 mainCtrl.wait_registry_empty(t, 10)
6211 mainCtrl.VerifyAllClean(t)
6214 //-----------------------------------------------------------------------------
6215 // TestRESTUnpackSubscriptionFailureDecodeFail
6218 // +-------+ +---------+ +---------+
6219 // | xapp | | submgr | | e2term |
6220 // +-------+ +---------+ +---------+
6223 // |---------------->| |
6225 // | RESTSubResp | |
6226 // |<----------------| |
6229 // | |------------->|
6231 // | | SubFail | ASN.1 decode fails
6232 // | |<-------------|
6235 // | |------------->|
6237 // | | SubFail | Duplicated action
6238 // | |<-------------|
6239 // | RESTNotif (fail)| |
6240 // |<----------------| |
6243 //-----------------------------------------------------------------------------
6244 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
6245 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
6246 const subReqCount int = 1
6249 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6250 restSubId := xappConn1.SendRESTSubsReq(t, params)
6252 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6254 // Decode of this response fails which will result resending original request
6255 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
6257 _, cremsg = e2termConn1.RecvSubsReq(t)
6259 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6261 // Subscription already created in E2 Node.
6262 fparams := &teststube2ap.E2StubSubsFailParams{}
6264 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6265 e2termConn1.SendSubsFail(t, fparams, cremsg)
6267 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6268 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6270 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6272 // Wait that subs is cleaned
6273 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6275 xappConn1.TestMsgChanEmpty(t)
6276 e2termConn1.TestMsgChanEmpty(t)
6277 mainCtrl.wait_registry_empty(t, 10)
6278 mainCtrl.VerifyAllClean(t)
6281 //-----------------------------------------------------------------------------
6282 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
6285 // +-------+ +---------+ +---------+
6286 // | xapp | | submgr | | e2term |
6287 // +-------+ +---------+ +---------+
6290 // |---------------->| |
6292 // | RESTSubResp | |
6293 // |<----------------| |
6296 // | |------------->|
6298 // | | SubFail | Unknown instanceId
6299 // | |<-------------|
6302 // | |------------->|
6304 // | | SubFail | Duplicated action
6305 // | |<-------------|
6306 // | RESTNotif (fail)| |
6307 // |<----------------| |
6309 // | |------------->|
6312 // | |<-------------|
6314 //-----------------------------------------------------------------------------
6315 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
6316 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
6317 const subReqCount int = 1
6320 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6321 restSubId := xappConn1.SendRESTSubsReq(t, params)
6323 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6325 // Unknown instanceId in this response which will result resending original request
6326 fparams := &teststube2ap.E2StubSubsFailParams{}
6328 fparams.Fail.RequestId.InstanceId = 0
6329 e2termConn1.SendSubsFail(t, fparams, cremsg)
6331 _, cremsg = e2termConn1.RecvSubsReq(t)
6333 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6335 // Subscription already created in E2 Node.
6336 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6337 e2termConn1.SendSubsFail(t, fparams, cremsg)
6339 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6340 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6342 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6343 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6345 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6347 // Wait that subs is cleaned
6348 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6350 xappConn1.TestMsgChanEmpty(t)
6351 e2termConn1.TestMsgChanEmpty(t)
6352 mainCtrl.wait_registry_empty(t, 10)
6353 mainCtrl.VerifyAllClean(t)
6356 //-----------------------------------------------------------------------------
6357 // TestRESTUnpackSubscriptionFailureNoTransaction
6360 // +-------+ +---------+ +---------+
6361 // | xapp | | submgr | | e2term |
6362 // +-------+ +---------+ +---------+
6365 // |---------------->| |
6367 // | RESTSubResp | |
6368 // |<----------------| |
6371 // | |------------->|
6373 // | | SubFail | No transaction for the response
6374 // | |<-------------|
6377 // | |------------->|
6379 // | | SubFail | Duplicated action
6380 // | |<-------------|
6381 // | RESTNotif (fail)| |
6382 // |<----------------| |
6384 // | |------------->|
6387 // | |<-------------|
6389 //-----------------------------------------------------------------------------
6390 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
6391 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
6392 const subReqCount int = 1
6395 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6396 restSubId := xappConn1.SendRESTSubsReq(t, params)
6398 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6400 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6402 // No transaction exist for this response which will result resending original request
6403 fparams := &teststube2ap.E2StubSubsFailParams{}
6405 e2termConn1.SendSubsFail(t, fparams, cremsg)
6407 _, cremsg = e2termConn1.RecvSubsReq(t)
6409 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6411 // Subscription already created in E2 Node.
6412 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6413 e2termConn1.SendSubsFail(t, fparams, cremsg)
6415 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6416 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6418 // Resending happens because there no transaction
6419 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6420 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6422 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6423 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6425 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6427 // Wait that subs is cleaned
6428 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6430 xappConn1.TestMsgChanEmpty(t)
6431 e2termConn1.TestMsgChanEmpty(t)
6432 mainCtrl.wait_registry_empty(t, 10)
6433 mainCtrl.VerifyAllClean(t)
6436 //-----------------------------------------------------------------------------
6437 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
6440 // +-------+ +---------+ +---------+
6441 // | xapp | | submgr | | e2term |
6442 // +-------+ +---------+ +---------+
6444 // | [SUBS CREATE] |
6447 // | RESTSubDelReq | |
6448 // |---------------->| |
6450 // | RESTSubDelResp | |
6451 // |<----------------| |
6454 // | |------------->|
6456 // | | SubDelResp | ASN.1 decode fails
6457 // | |<-------------|
6460 // | |------------->|
6462 // | | SubDelFail | Subscription does exist any more
6463 // | |<-------------|
6466 //-----------------------------------------------------------------------------
6467 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
6468 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail")
6471 var params *teststube2ap.RESTSubsReqParams = nil
6472 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6475 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6477 // E2t: Receive 1st SubsDelReq
6478 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6480 // Decode of this response fails which will result resending original request
6481 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_REQ)
6483 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6484 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6486 // Subscription does not exist in in E2 Node.
6487 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6489 // Wait that subs is cleaned
6490 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6492 xappConn1.TestMsgChanEmpty(t)
6493 e2termConn1.TestMsgChanEmpty(t)
6494 mainCtrl.wait_registry_empty(t, 10)
6495 mainCtrl.VerifyAllClean(t)
6498 //-----------------------------------------------------------------------------
6499 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
6502 // +-------+ +---------+ +---------+
6503 // | xapp | | submgr | | e2term |
6504 // +-------+ +---------+ +---------+
6506 // | [SUBS CREATE] |
6509 // | RESTSubDelReq | |
6510 // |---------------->| |
6512 // | RESTSubDelResp | |
6513 // |<----------------| |
6516 // | |------------->|
6518 // | | SubDelResp | Unknown instanceId
6519 // | |<-------------|
6522 // | |------------->|
6524 // | | SubDelFail | Subscription does exist any more
6525 // | |<-------------|
6527 //-----------------------------------------------------------------------------
6528 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
6529 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId")
6532 var params *teststube2ap.RESTSubsReqParams = nil
6533 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6536 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6538 // E2t: Receive 1st SubsDelReq
6539 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6541 // Unknown instanceId in this response which will result resending original request
6542 delreq.RequestId.InstanceId = 0
6543 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6545 // E2t: Receive 2nd SubsDelReq
6546 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6548 // Subscription does not exist in in E2 Node.
6549 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6551 // Wait that subs is cleaned
6552 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6554 xappConn1.TestMsgChanEmpty(t)
6555 e2termConn1.TestMsgChanEmpty(t)
6556 mainCtrl.wait_registry_empty(t, 10)
6557 mainCtrl.VerifyAllClean(t)
6560 //-----------------------------------------------------------------------------
6561 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
6564 // +-------+ +---------+ +---------+
6565 // | xapp | | submgr | | e2term |
6566 // +-------+ +---------+ +---------+
6568 // | [SUBS CREATE] |
6571 // | RESTSubDelReq | |
6572 // |---------------->| |
6574 // | RESTSubDelResp | |
6575 // |<----------------| |
6578 // | |------------->|
6580 // | | SubDelResp | No transaction for the response
6581 // | |<-------------|
6584 // | |------------->|
6586 // | | SubDelFail | Subscription does exist any more
6587 // | |<-------------|
6589 //-----------------------------------------------------------------------------
6590 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
6591 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction")
6594 var params *teststube2ap.RESTSubsReqParams = nil
6595 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6598 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6600 // E2t: Receive 1st SubsDelReq
6601 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6603 mainCtrl.MakeTransactionNil(t, e2SubsId)
6605 // No transaction exist for this response which will result resending original request
6606 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6608 // E2t: Receive 2nd SubsDelReq
6609 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6611 // Subscription does not exist in in E2 Node.
6612 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6614 // Wait that subs is cleaned
6615 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6617 xappConn1.TestMsgChanEmpty(t)
6618 e2termConn1.TestMsgChanEmpty(t)
6619 mainCtrl.wait_registry_empty(t, 10)
6620 mainCtrl.VerifyAllClean(t)
6623 //-----------------------------------------------------------------------------
6624 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
6627 // +-------+ +---------+ +---------+
6628 // | xapp | | submgr | | e2term |
6629 // +-------+ +---------+ +---------+
6631 // | [SUBS CREATE] |
6634 // | RESTSubDelReq | |
6635 // |---------------->| |
6637 // | RESTSubDelResp | |
6638 // |<----------------| |
6641 // | |------------->|
6643 // | | SubDelFail | ASN.1 decode fails
6644 // | |<-------------|
6647 // | |------------->|
6649 // | | SubDelFail | Subscription does exist any more
6650 // | |<-------------|
6652 //-----------------------------------------------------------------------------
6653 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
6654 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail")
6657 var params *teststube2ap.RESTSubsReqParams = nil
6658 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6661 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6663 // E2t: Receive 1st SubsDelReq
6664 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6666 // Decode of this response fails which will result resending original request
6667 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
6669 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6670 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6672 // Subscription does not exist in in E2 Node.
6673 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6675 // Wait that subs is cleaned
6676 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6678 xappConn1.TestMsgChanEmpty(t)
6679 e2termConn1.TestMsgChanEmpty(t)
6680 mainCtrl.wait_registry_empty(t, 10)
6681 mainCtrl.VerifyAllClean(t)
6684 //-----------------------------------------------------------------------------
6685 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
6688 // +-------+ +---------+ +---------+
6689 // | xapp | | submgr | | e2term |
6690 // +-------+ +---------+ +---------+
6692 // | [SUBS CREATE] |
6695 // | RESTSubDelReq | |
6696 // |---------------->| |
6698 // | RESTSubDelResp | |
6699 // |<----------------| |
6702 // | |------------->|
6704 // | | SubDelFail | Unknown instanceId
6705 // | |<-------------|
6708 // | |------------->|
6710 // | | SubDelFail | Subscription does exist any more
6711 // | |<-------------|
6713 //-----------------------------------------------------------------------------
6714 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
6715 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId")
6718 var params *teststube2ap.RESTSubsReqParams = nil
6719 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6722 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6724 // E2t: Receive 1st SubsDelReq
6725 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6727 // Unknown instanceId in this response which will result resending original request
6728 delreq.RequestId.InstanceId = 0
6729 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6731 // E2t: Receive 2nd SubsDelReq
6732 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6734 // Subscription does not exist in in E2 Node.
6735 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6737 // Wait that subs is cleaned
6738 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6740 xappConn1.TestMsgChanEmpty(t)
6741 e2termConn1.TestMsgChanEmpty(t)
6742 mainCtrl.wait_registry_empty(t, 10)
6743 mainCtrl.VerifyAllClean(t)
6746 //-----------------------------------------------------------------------------
6747 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
6750 // +-------+ +---------+ +---------+
6751 // | xapp | | submgr | | e2term |
6752 // +-------+ +---------+ +---------+
6754 // | [SUBS CREATE] |
6757 // | RESTSubDelReq | |
6758 // |---------------->| |
6760 // | RESTSubDelResp | |
6761 // |<----------------| |
6764 // | |------------->|
6766 // | | SubDelFail | No transaction for the response
6767 // | |<-------------|
6770 // | |------------->|
6772 // | | SubDelFail | Subscription does exist any more
6773 // | |<-------------|
6775 //-----------------------------------------------------------------------------
6776 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
6777 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction")
6780 var params *teststube2ap.RESTSubsReqParams = nil
6781 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6784 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6786 // E2t: Receive 1st SubsDelReq
6787 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6789 mainCtrl.MakeTransactionNil(t, e2SubsId)
6791 // No transaction exist for this response which will result resending original request
6792 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6794 // E2t: Receive 2nd SubsDelReq
6795 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6797 // Subscription does not exist in in E2 Node.
6798 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6800 // Wait that subs is cleaned
6801 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6803 xappConn1.TestMsgChanEmpty(t)
6804 e2termConn1.TestMsgChanEmpty(t)
6805 mainCtrl.wait_registry_empty(t, 10)
6806 mainCtrl.VerifyAllClean(t)
6809 //-----------------------------------------------------------------------------
6810 // TestRESTSubReqFailAsn1PackSubReqError
6813 // +-------+ +---------+ +---------+
6814 // | xapp | | submgr | | e2term |
6815 // +-------+ +---------+ +---------+
6818 // |---------------->| |
6820 // | RESTSubResp | |
6821 // |<----------------| |
6823 // | ASN.1 encode fails |
6826 // | |------------->|
6829 // | |<-------------|
6833 // |<----------------| |
6835 // | [SUBS DELETE] |
6838 //-----------------------------------------------------------------------------
6839 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
6841 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6842 Counter{cRestSubReqFromXapp, 1},
6843 Counter{cRestSubRespToXapp, 1},
6844 Counter{cRestSubFailNotifToXapp, 1},
6845 Counter{cRestSubDelReqFromXapp, 1},
6846 Counter{cRestSubDelRespToXapp, 1},
6849 const subReqCount int = 1
6851 var params *teststube2ap.RESTSubsReqParams = nil
6852 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
6853 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
6856 restSubId := xappConn1.SendRESTSubsReq(t, params)
6857 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
6859 // E2t: Receive SubsDelReq
6860 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6862 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6863 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
6865 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
6867 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6869 // Wait that subs is cleaned
6870 waitSubsCleanup(t, e2SubsId, 10)
6871 mainCtrl.VerifyCounterValues(t)
6872 mainCtrl.VerifyAllClean(t)
6875 func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
6876 CaseBegin("TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction")
6878 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6879 Counter{cRestSubReqFromXapp, 2},
6880 Counter{cRestSubRespToXapp, 2},
6881 Counter{cSubReqToE2, 2},
6882 Counter{cSubReqTimerExpiry, 1},
6883 Counter{cSubRespFromE2, 1},
6884 Counter{cRestSubNotifToXapp, 1},
6885 Counter{cRestSubFailNotifToXapp, 1},
6886 Counter{cRestSubDelReqFromXapp, 1},
6887 Counter{cSubDelReqToE2, 1},
6888 Counter{cSubDelRespFromE2, 1},
6889 Counter{cRestSubDelRespToXapp, 1},
6892 const e2Timeout int64 = 1
6893 const e2RetryCount int64 = 0
6894 const routingNeeded bool = false
6897 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6898 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6901 restSubId := xappConn1.SendRESTSubsReq(t, params)
6902 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6904 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6905 xappConn1.ExpectRESTNotification(t, restSubId)
6906 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
6907 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6908 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
6911 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6912 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6913 params.SetSubscriptionID(&restSubId)
6914 params.SetTimeToWait("w200ms")
6915 restSubId = xappConn1.SendRESTSubsReq(t, params)
6916 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6918 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
6919 xappConn1.ExpectRESTNotification(t, restSubId)
6920 // SubsResp is missing, e2SubsId will be 0
6921 zeroE2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6922 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", zeroE2SubsId)
6925 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6926 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6927 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6929 waitSubsCleanup(t, e2SubsId, 10)
6931 mainCtrl.VerifyCounterValues(t)
6932 mainCtrl.VerifyAllClean(t)
6935 //-----------------------------------------------------------------------------
6936 // TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle
6939 // +-------+ +---------+ +---------+
6940 // | xapp | | submgr | | e2term |
6941 // +-------+ +---------+ +---------+
6944 // |---------------->| |
6946 // | RESTSubResp | |
6947 // |<----------------| |
6949 // | |------------->|
6952 // | |<-------------|
6955 // |<----------------| |
6958 // |---------------->| |
6960 // | RESTSubResp | |
6961 // |<----------------| |
6963 // | |------------->|
6965 // | Submgr restart |
6967 // | RESTSubDelReq | |
6968 // |---------------->| |
6971 // | |------------->|
6974 // | |<-------------|
6976 // | RESTSubDelResp | |
6977 // |<----------------| |
6979 //-----------------------------------------------------------------------------
6981 func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
6982 CaseBegin("TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle")
6984 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6985 Counter{cRestSubReqFromXapp, 2},
6986 Counter{cRestSubRespToXapp, 2},
6987 Counter{cSubReqToE2, 2},
6988 Counter{cSubRespFromE2, 1},
6989 Counter{cRestSubNotifToXapp, 1},
6990 Counter{cRestSubDelReqFromXapp, 1},
6991 Counter{cSubDelReqToE2, 1},
6992 Counter{cSubDelRespFromE2, 1},
6993 Counter{cRestSubDelRespToXapp, 1},
6996 const e2Timeout int64 = 1
6997 const e2RetryCount int64 = 0
6998 const routingNeeded bool = false
7001 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7002 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7003 // Create subscription
7004 restSubId := xappConn1.SendRESTSubsReq(t, params)
7005 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
7007 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7008 xappConn1.ExpectRESTNotification(t, restSubId)
7009 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
7010 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7011 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7013 // Check subscription
7014 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
7017 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7018 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7019 params.SetSubscriptionID(&restSubId)
7020 params.SetTimeToWait("w200ms")
7021 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
7022 restSubId = xappConn1.SendRESTSubsReq(t, params)
7023 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
7025 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
7026 mainCtrl.SetResetTestFlag(t, false)
7028 // SubsResp is missing due to submgr restart
7030 mainCtrl.SimulateRestart(t)
7031 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
7033 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
7034 // That needs to be completed before successful subscription query is possible
7035 <-time.After(time.Second * 1)
7037 // Check subscription
7038 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
7040 // Delete subscription
7041 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7042 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7043 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7045 //Wait that subs is cleaned
7046 waitSubsCleanup(t, e2SubsId, 10)
7048 mainCtrl.VerifyCounterValues(t)
7049 mainCtrl.VerifyAllClean(t)
7052 ////////////////////////////////////////////////////////////////////////////////////
7053 // Services for UT cases
7054 ////////////////////////////////////////////////////////////////////////////////////
7055 const subReqCount int = 1
7056 const host string = "localhost"
7058 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
7060 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
7062 restSubId := fromXappConn.SendRESTSubsReq(t, params)
7063 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
7065 crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
7066 fromXappConn.ExpectRESTNotification(t, restSubId)
7067 toE2termConn.SendSubsResp(t, crereq1, cremsg1)
7068 e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
7069 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7071 return restSubId, e2SubsId
7074 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
7076 params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
7078 params.SetMeid(meid)
7080 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
7081 restSubId := xappConn2.SendRESTSubsReq(t, params)
7082 xappConn2.ExpectRESTNotification(t, restSubId)
7083 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
7084 e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
7085 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7087 return restSubId, e2SubsId
7090 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
7092 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7093 restSubId := xappConn1.SendRESTSubsReq(t, params)
7094 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
7096 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7097 xappConn1.ExpectRESTNotification(t, restSubId)
7098 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
7099 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7100 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7102 return restSubId, e2SubsId
7105 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
7106 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7107 restSubId := xappConn1.SendRESTSubsReq(t, params)
7109 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7110 fparams1 := &teststube2ap.E2StubSubsFailParams{}
7111 fparams1.Set(crereq1)
7112 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
7114 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
7115 xappConn1.ExpectRESTNotification(t, restSubId)
7116 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
7117 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7118 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
7120 return restSubId, e2SubsId
7123 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
7124 fromXappConn.SendRESTSubsDelReq(t, restSubId)
7125 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
7126 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
7129 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
7130 xappConn1.SendRESTSubsDelReq(t, restSubId)
7131 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7132 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7135 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
7136 xappConn2.SendRESTSubsDelReq(t, restSubId)
7137 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7138 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7141 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
7142 resp, _ := xapp.Subscription.QuerySubscriptions()
7143 assert.Equal(t, e2SubsId, resp[0].SubscriptionID)
7144 assert.Equal(t, meid, resp[0].Meid)
7145 assert.Equal(t, endpoint, resp[0].ClientEndpoint)
7148 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
7149 //Wait that subs is cleaned
7150 mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
7152 xappConn1.TestMsgChanEmpty(t)
7153 xappConn2.TestMsgChanEmpty(t)
7154 e2termConn1.TestMsgChanEmpty(t)
7155 mainCtrl.wait_registry_empty(t, timeout)
7158 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
7160 var e2SubsId []uint32
7162 for i := 0; i < count; i++ {
7163 xapp.Logger.Debug("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
7164 crereq, cremsg := toE2termConn.RecvSubsReq(t)
7165 fromXappConn.ExpectRESTNotification(t, restSubId)
7166 toE2termConn.SendSubsResp(t, crereq, cremsg)
7167 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
7168 e2SubsId = append(e2SubsId, instanceId)
7169 xapp.Logger.Debug("TEST: %v", e2SubsId)
7170 xapp.Logger.Debug("TEST: %d ===================================== END CRE ============================================", i+1)
7171 <-time.After(100 * time.Millisecond)
7176 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
7178 for i := 0; i < len(e2SubsIds); i++ {
7179 xapp.Logger.Debug("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
7180 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
7181 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
7182 <-time.After(1 * time.Second)
7183 xapp.Logger.Debug("TEST: %d ===================================== END DEL ============================================", i+1)
7184 <-time.After(100 * time.Millisecond)
7187 // Wait that subs is cleaned
7188 for i := 0; i < len(e2SubsIds); i++ {
7189 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)