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 // Remove possible existing subscrition
2379 mainCtrl.removeExistingSubscriptions(t)
2381 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
2382 xappConn1.SendSubsReq(t, nil, nil)
2383 e2termConn1.RecvSubsReq(t)
2384 mainCtrl.SetResetTestFlag(t, false)
2386 resp, _ := xapp.Subscription.QuerySubscriptions()
2387 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2388 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2389 e2SubsId := uint32(resp[0].SubscriptionID)
2390 t.Logf("e2SubsId = %v", e2SubsId)
2392 mainCtrl.SimulateRestart(t)
2393 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2395 // Submgr send delete for uncompleted subscription
2396 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2397 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2399 // Wait that subs is cleaned
2400 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2402 xappConn1.TestMsgChanEmpty(t)
2403 xappConn2.TestMsgChanEmpty(t)
2404 e2termConn1.TestMsgChanEmpty(t)
2405 mainCtrl.wait_registry_empty(t, 10)
2408 //-----------------------------------------------------------------------------
2409 // TestSubReqAndSubDelOkWithRestartInMiddle
2412 // +-------+ +---------+ +---------+
2413 // | xapp | | submgr | | e2term |
2414 // +-------+ +---------+ +---------+
2417 // |------------->| |
2420 // | |------------->|
2423 // | |<-------------|
2426 // |<-------------| |
2429 // | Submgr restart |
2432 // |------------->| |
2435 // | |------------->|
2438 // | |<-------------|
2441 // |<-------------| |
2443 //-----------------------------------------------------------------------------
2445 func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
2446 CaseBegin("TestSubReqAndSubDelOkWithRestartInMiddle")
2448 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2449 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2450 e2termConn1.SendSubsResp(t, crereq, cremsg)
2451 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2453 // Check subscription
2454 resp, _ := xapp.Subscription.QuerySubscriptions()
2455 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2456 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2457 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2459 mainCtrl.SimulateRestart(t)
2460 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2462 // Check that subscription is restored correctly after restart
2463 resp, _ = xapp.Subscription.QuerySubscriptions()
2464 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2465 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2466 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2468 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2469 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2470 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2471 xappConn1.RecvSubsDelResp(t, deltrans)
2473 //Wait that subs is cleaned
2474 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2476 xappConn1.TestMsgChanEmpty(t)
2477 xappConn2.TestMsgChanEmpty(t)
2478 e2termConn1.TestMsgChanEmpty(t)
2479 mainCtrl.wait_registry_empty(t, 10)
2482 //-----------------------------------------------------------------------------
2483 // TestSubReqAndSubDelOkSameActionWithRestartsInMiddle
2486 // +-------+ +-------+ +---------+ +---------+
2487 // | xapp2 | | xapp1 | | submgr | | e2term |
2488 // +-------+ +-------+ +---------+ +---------+
2493 // | |------------->| |
2496 // | | |------------->|
2498 // | | |<-------------|
2500 // | |<-------------| |
2503 // | submgr restart |
2508 // |--------------------------->| |
2511 // |<---------------------------| |
2513 // | | SubDelReq 1 | |
2514 // | |------------->| |
2516 // | | SubDelResp 1 | |
2517 // | |<-------------| |
2521 // | submgr restart |
2524 // | SubDelReq 2 | |
2525 // |--------------------------->| |
2527 // | | | SubDelReq 2 |
2528 // | | |------------->|
2530 // | | | SubDelReq 2 |
2531 // | | |------------->|
2533 // | SubDelResp 2 | |
2534 // |<---------------------------| |
2536 //-----------------------------------------------------------------------------
2538 func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
2539 CaseBegin("TestSubReqAndSubDelOkSameActionWithRestartsInMiddle")
2542 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2544 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2545 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2546 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2547 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2550 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2552 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2553 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
2555 // Check subscription
2556 resp, _ := xapp.Subscription.QuerySubscriptions() ////////////////////////////////
2557 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2558 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2559 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2561 mainCtrl.SimulateRestart(t)
2562 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2564 // Check that subscription is restored correctly after restart
2565 resp, _ = xapp.Subscription.QuerySubscriptions()
2566 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2567 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2568 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2571 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2572 xapp.Logger.Debug("xappConn1.RecvSubsDelResp")
2573 xappConn1.RecvSubsDelResp(t, deltrans1)
2574 xapp.Logger.Debug("xappConn1.RecvSubsDelResp received")
2576 mainCtrl.SimulateRestart(t)
2577 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2580 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
2581 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2583 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2584 xappConn2.RecvSubsDelResp(t, deltrans2)
2586 //Wait that subs is cleaned
2587 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2589 xappConn1.TestMsgChanEmpty(t)
2590 xappConn2.TestMsgChanEmpty(t)
2591 e2termConn1.TestMsgChanEmpty(t)
2592 mainCtrl.wait_registry_empty(t, 10)
2595 //*****************************************************************************
2596 // REST interface test cases
2597 //*****************************************************************************
2599 //-----------------------------------------------------------------------------
2600 // Test debug GET and POST requests
2603 // +-------+ +---------+
2604 // | user | | submgr |
2605 // +-------+ +---------+
2612 func TestGetSubscriptions(t *testing.T) {
2614 mainCtrl.sendGetRequest(t, "localhost:8088", "/ric/v1/subscriptions")
2617 func TestGetSymptomData(t *testing.T) {
2619 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/symptomdata")
2622 func TestPostdeleteSubId(t *testing.T) {
2624 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/deletesubid=1")
2627 func TestPostEmptyDb(t *testing.T) {
2629 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/emptydb")
2632 func TestGetRestSubscriptions(t *testing.T) {
2634 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/restsubscriptions")
2637 //-----------------------------------------------------------------------------
2638 // TestRESTSubReqAndRouteNok
2641 // +-------+ +---------+ +---------+
2642 // | xapp | | submgr | | rtmgr |
2643 // +-------+ +---------+ +---------+
2646 // |---------------->| |
2648 // | RESTSubResp | |
2649 // |<----------------| |
2650 // | | RouteCreate |
2651 // | |------------->|
2653 // | | RouteCreate |
2655 // | |(Bad request) |
2656 // | |<-------------|
2658 // |<----------------| |
2660 // | [SUBS INT DELETE] |
2662 // | RESTSubDelReq | |
2663 // |---------------->| |
2664 // | RESTSubDelResp | |
2665 // |<----------------| |
2667 //-----------------------------------------------------------------------------
2668 func TestRESTSubReqAndRouteNok(t *testing.T) {
2669 CaseBegin("TestRESTSubReqAndRouteNok")
2671 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2672 Counter{cRestSubReqFromXapp, 1},
2673 Counter{cRestSubRespToXapp, 1},
2674 Counter{cRouteCreateFail, 1},
2675 Counter{cRestSubFailNotifToXapp, 1},
2676 Counter{cRestSubDelReqFromXapp, 1},
2677 Counter{cRestSubDelRespToXapp, 1},
2680 const subReqCount int = 1
2682 // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
2683 waiter := rtmgrHttp.AllocNextSleep(50, false)
2684 newSubsId := mainCtrl.get_registry_next_subid(t)
2687 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2688 restSubId := xappConn1.SendRESTSubsReq(t, params)
2689 xappConn1.ExpectRESTNotificationNok(t, restSubId, "failAll")
2690 waiter.WaitResult(t)
2692 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2693 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
2696 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2698 // Wait that subs is cleaned
2699 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2700 waitSubsCleanup(t, e2SubsId, 10)
2701 mainCtrl.VerifyCounterValues(t)
2702 //mainCtrl.VerifyAllClean(t)
2705 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
2706 CaseBegin("TestSubReqAndRouteUpdateNok")
2708 //Init counter check
2709 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2710 Counter{cRestSubReqFromXapp, 2},
2711 Counter{cRestSubRespToXapp, 2},
2712 Counter{cSubReqToE2, 1},
2713 Counter{cSubRespFromE2, 1},
2714 Counter{cRestSubNotifToXapp, 1},
2715 Counter{cRestSubFailNotifToXapp, 1},
2716 Counter{cRouteCreateUpdateFail, 1},
2717 Counter{cRestSubDelReqFromXapp, 1},
2718 Counter{cSubDelReqToE2, 1},
2719 Counter{cSubDelRespFromE2, 1},
2720 Counter{cRestSubDelRespToXapp, 1},
2723 var params *teststube2ap.RESTSubsReqParams = nil
2726 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2728 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2730 // xapp2 ROUTE creation shall fail with 400 from rtmgr -> submgr
2731 waiter := rtmgrHttp.AllocNextEvent(false)
2732 newSubsId := mainCtrl.get_registry_next_subid(t)
2733 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
2734 params.SetMeid("RAN_NAME_1")
2735 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2736 xapp.Logger.Debug("Send REST subscriber request for second subscriber : %v", restSubId2)
2737 xappConn2.ExpectRESTNotificationNok(t, restSubId2, "allFail")
2738 waiter.WaitResult(t)
2739 // e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) - TOD: missing delete
2740 xappConn2.WaitRESTNotification(t, restSubId2)
2742 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2744 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2746 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2747 //Wait that subs is cleaned
2748 waitSubsCleanup(t, e2SubsId, 10)
2750 mainCtrl.VerifyCounterValues(t)
2751 //mainCtrl.VerifyAllClean(t) //This test case is not working correctly
2754 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
2755 CaseBegin("TestRESTSubDelReqAndRouteDeleteNok")
2757 // Init counter check
2758 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2759 Counter{cRestSubReqFromXapp, 1},
2760 Counter{cRestSubRespToXapp, 1},
2761 Counter{cSubReqToE2, 1},
2762 Counter{cSubRespFromE2, 1},
2763 Counter{cRestSubNotifToXapp, 1},
2764 Counter{cRestSubDelReqFromXapp, 1},
2765 Counter{cRouteDeleteFail, 1},
2766 Counter{cSubDelReqToE2, 1},
2767 Counter{cSubDelRespFromE2, 1},
2768 Counter{cRestSubDelRespToXapp, 1},
2771 var params *teststube2ap.RESTSubsReqParams = nil
2774 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2776 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2778 waiter := rtmgrHttp.AllocNextEvent(false)
2779 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2780 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2781 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2782 waiter.WaitResult(t)
2784 waitSubsCleanup(t, e2SubsId, 10)
2786 mainCtrl.VerifyCounterValues(t)
2787 ////mainCtrl.VerifyAllClean(t) This test case is not working correctly
2790 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
2791 CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok")
2793 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2794 Counter{cRestSubReqFromXapp, 2},
2795 Counter{cMergedSubscriptions, 1},
2796 Counter{cRestSubRespToXapp, 2},
2797 Counter{cSubReqToE2, 1},
2798 Counter{cSubRespFromE2, 1},
2799 Counter{cRestSubNotifToXapp, 2},
2800 Counter{cRestSubDelReqFromXapp, 2},
2801 Counter{cRouteDeleteUpdateFail, 1},
2802 Counter{cSubDelReqToE2, 1},
2803 Counter{cSubDelRespFromE2, 1},
2804 Counter{cRestSubDelRespToXapp, 2},
2805 Counter{cUnmergedSubscriptions, 1},
2808 var params *teststube2ap.RESTSubsReqParams = nil
2811 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2813 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2814 restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1")
2816 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
2818 //Del1, this shall fail on rtmgr side
2819 waiter := rtmgrHttp.AllocNextEvent(false)
2820 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2821 waiter.WaitResult(t)
2823 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"})
2826 deleteXapp2Subscription(t, &restSubId2)
2828 waitSubsCleanup(t, e2SubsId2, 10)
2829 mainCtrl.VerifyCounterValues(t)
2830 //mainCtrl.VerifyAllClean(t)
2833 //-----------------------------------------------------------------------------
2834 // TestRESTSubReqRetransmission
2837 // +-------+ +---------+ +---------+
2838 // | xapp | | submgr | | e2term |
2839 // +-------+ +---------+ +---------+
2841 // | RESTSubReq1 | |
2842 // |---------------->| |
2844 // | RESTSubResp | |
2845 // |<----------------| |
2847 // | |------------->|
2849 // | RESTSubReq2 | |
2851 // |---------------->| |
2852 // | RESTSubResp(201)| |
2853 // |<----------------| |
2856 // | |<-------------|
2858 // |<----------------| |
2860 // | [SUBS DELETE] |
2863 //-----------------------------------------------------------------------------
2865 func TestRESTSubReqRetransmission(t *testing.T) {
2866 CaseBegin("TestRESTSubReqRetransmission")
2868 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2869 Counter{cRestSubReqFromXapp, 2},
2870 Counter{cRestSubRespToXapp, 2},
2871 Counter{cSubReqToE2, 1},
2872 Counter{cSubRespFromE2, 1},
2873 Counter{cRestSubNotifToXapp, 1},
2874 Counter{cRestSubDelReqFromXapp, 1},
2875 Counter{cSubDelReqToE2, 1},
2876 Counter{cSubDelRespFromE2, 1},
2877 Counter{cRestSubDelRespToXapp, 1},
2879 // Retry/duplicate will get the same way as the first request.
2880 // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
2881 // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
2884 const subReqCount int = 1
2886 // In order to force both XAPP's to create their own subscriptions, force rtmgr to block a while so that 2nd create
2887 // gets into execution before the rtmgrg responds for the first one.
2888 waiter := rtmgrHttp.AllocNextSleep(10, true)
2889 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2890 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
2891 xappConn2.SendRESTSubsReq(t, params)
2893 waiter.WaitResult(t)
2895 xappConn1.WaitListedRestNotifications(t, []string{restSubId1})
2897 // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
2898 // the order is not significant he6re.
2899 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2900 e2termConn1.SendSubsResp(t, crereq, cremsg)
2902 e2SubsIdA := <-xappConn1.ListedRESTNotifications
2903 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
2906 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
2907 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2908 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2910 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId}, 10)
2912 mainCtrl.VerifyCounterValues(t)
2913 //mainCtrl.VerifyAllClean(t)
2916 //-----------------------------------------------------------------------------
2918 // +-------+ +---------+ +---------+ +---------+
2919 // | xapp | | submgr | | e2term | | rtmgr |
2920 // +-------+ +---------+ +---------+ +---------+
2922 // | RESTSubReq | | |
2923 // |---------------->| | |
2924 // | RESTSubResp | | |
2925 // |<----------------| | |
2926 // | | RouteCreate | |
2927 // | |--------------------------->|
2928 // | | RouteResponse| |
2929 // | |<---------------------------| // The order of these events may vary
2931 // | |------------->| | // The order of these events may vary
2933 // | |<-------------| |
2934 // | RESTNotif1 | | |
2935 // |<----------------| | |
2936 // | RESTSubReq | | |
2937 // | [RETRANS1] | | |
2938 // |---------------->| | |
2939 // | RESTNotif1 | | |
2940 // |<----------------| | |
2941 // | RESTSubReq | | |
2942 // | [RETRANS2] | | |
2943 // |---------------->| | |
2944 // | RESTNotif1 | | |
2945 // |<----------------| | |
2946 // | RESTSubDelReq | | |
2947 // |---------------->| | |
2948 // | | SubDelReq | |
2949 // | |------------->| |
2950 // | RESTSubDelResp| | |
2951 // |<----------------| | |
2952 // | | SubDelResp | |
2953 // | |<-------------| |
2956 //-----------------------------------------------------------------------------
2958 func TestRESTSubReqRetransmissionV2(t *testing.T) {
2959 CaseBegin("TestRESTSubReqRetransmissionV2")
2961 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2962 Counter{cRestSubReqFromXapp, 3},
2963 Counter{cDuplicateE2SubReq, 2},
2964 Counter{cRestSubRespToXapp, 3},
2965 Counter{cSubReqToE2, 1},
2966 Counter{cSubRespFromE2, 1},
2967 Counter{cRestSubNotifToXapp, 3},
2968 Counter{cRestSubDelReqFromXapp, 1},
2969 Counter{cSubDelReqToE2, 1},
2970 Counter{cSubDelRespFromE2, 1},
2971 Counter{cRestSubDelRespToXapp, 1},
2974 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2976 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2978 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2981 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
2983 assert.Equal(t, restSubId_resend, restSubId)
2985 <-time.After(100 * time.Millisecond)
2988 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
2990 assert.Equal(t, restSubId_resend2, restSubId)
2992 <-time.After(100 * time.Millisecond)
2994 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2996 waitSubsCleanup(t, e2SubsId, 10)
2998 //Wait that subs is cleaned
2999 mainCtrl.VerifyCounterValues(t)
3000 //mainCtrl.VerifyAllClean(t)
3003 //-----------------------------------------------------------------------------
3005 // +-------+ +---------+ +---------+ +---------+
3006 // | xapp | | submgr | | e2term | | rtmgr |
3007 // +-------+ +---------+ +---------+ +---------+
3009 // | RESTSubReq | | |
3010 // |---------------->| | |
3011 // | RESTSubResp | | |
3012 // |<----------------| | |
3013 // | | RouteCreate | |
3014 // | |--------------------------->|
3015 // | | RouteResponse| |
3016 // | |<---------------------------| // The order of these events may vary
3018 // | |------------->| | // The order of these events may vary
3020 // | |<-------------| |
3021 // | RESTNotif1 | | |
3022 // |<----------------| | |
3023 // | RESTSubReq | | |
3024 // | [RETRANS, with RESTsubsId] | |
3025 // |---------------->| | |
3026 // | RESTNotif1 | | |
3027 // |<----------------| | |
3028 // | RESTSubReq | | |
3029 // | [RETRANS, without RESTsubsId] | |
3030 // |---------------->| | |
3031 // | RESTNotif1 | | |
3032 // |<----------------| | |
3033 // | RESTSubDelReq | | |
3034 // |---------------->| | |
3035 // | | SubDelReq | |
3036 // | |------------->| |
3037 // | RESTSubDelResp| | |
3038 // |<----------------| | |
3039 // | | SubDelResp | |
3040 // | |<-------------| |
3043 //-----------------------------------------------------------------------------
3044 func TestRESTSubReqRetransmissionV3(t *testing.T) {
3045 CaseBegin("TestRESTSubReqRetransmissionV3")
3047 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3048 Counter{cRestSubReqFromXapp, 3},
3049 Counter{cDuplicateE2SubReq, 2},
3050 Counter{cRestSubRespToXapp, 3},
3051 Counter{cSubReqToE2, 1},
3052 Counter{cSubRespFromE2, 1},
3053 Counter{cRestSubNotifToXapp, 3},
3054 Counter{cRestSubDelReqFromXapp, 1},
3055 Counter{cSubDelReqToE2, 1},
3056 Counter{cSubDelRespFromE2, 1},
3057 Counter{cRestSubDelRespToXapp, 1},
3060 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3062 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3064 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3066 <-time.After(100 * time.Millisecond)
3068 //1.st resend with subscription ID
3069 params.SetSubscriptionID(&restSubId)
3070 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
3072 assert.Equal(t, restSubId_resend, restSubId)
3074 <-time.After(100 * time.Millisecond)
3076 //2.nd resend without subscription ID (faking app restart)
3077 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3078 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3080 assert.Equal(t, restSubId_resend2, restSubId)
3082 <-time.After(100 * time.Millisecond)
3084 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3086 waitSubsCleanup(t, e2SubsId, 10)
3088 //Wait that subs is cleaned
3089 mainCtrl.VerifyCounterValues(t)
3090 //mainCtrl.VerifyAllClean(t)
3093 //-----------------------------------------------------------------------------
3095 // +-------+ +---------+ +---------+ +---------+
3096 // | xapp | | submgr | | e2term | | rtmgr |
3097 // +-------+ +---------+ +---------+ +---------+
3099 // | RESTSubReq | | |
3100 // |---------------->| | |
3101 // | RESTSubResp | | |
3102 // |<----------------| | |
3103 // | | RouteCreate | |
3104 // | |--------------------------->|
3105 // | | RouteResponse| |
3106 // | |<---------------------------|
3108 // | |------------->| |
3110 // | |<-------------| |
3111 // | RESTNotif1 | | |
3112 // |<----------------| | |
3113 // | RESTSubReq | | |
3114 // | [with RestSUbsId + one additional e2 subDetail]
3115 // |---------------->| | |
3116 // | RESTNotif1 | | |
3117 // | [for initial e2 subDetail] | |
3118 // |<----------------| | |
3119 // | | RouteCreate | |
3120 // | |--------------------------->|
3121 // | | RouteResponse| |
3122 // | |<---------------------------|
3124 // | |------------->| |
3126 // | |<-------------| |
3127 // | RESTNotif1 | | |
3128 // |<----------------| | |
3129 // | RESTSubReq | | |
3130 // | [with RESTsubsId initial request] |
3131 // |---------------->| | |
3132 // | RESTNotif1 | | |
3133 // |<----------------| | |
3134 // | RESTSubDelReq | | |
3135 // |---------------->| | |
3136 // | RESTSubDelResp| | |
3137 // |<----------------| | |
3138 // | | SubDelReq | |
3139 // | |------------->| |
3140 // | | SubDelResp | |
3141 // | |<-------------| |
3142 // | | SubDelReq | |
3143 // | |------------->| |
3144 // | | SubDelResp | |
3145 // | |<-------------| |
3148 //-----------------------------------------------------------------------------
3150 func TestRESTSubReqRetransmissionV4(t *testing.T) {
3151 CaseBegin("TestRESTSubReqRetransmissionV4")
3153 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3154 Counter{cRestSubReqFromXapp, 3},
3155 Counter{cDuplicateE2SubReq, 2},
3156 Counter{cRestSubRespToXapp, 3},
3157 Counter{cSubReqToE2, 2},
3158 Counter{cSubRespFromE2, 2},
3159 Counter{cRestSubNotifToXapp, 4},
3160 Counter{cRestSubDelReqFromXapp, 1},
3161 Counter{cSubDelReqToE2, 2},
3162 Counter{cSubDelRespFromE2, 2},
3163 Counter{cRestSubDelRespToXapp, 1},
3166 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3168 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3170 <-time.After(100 * time.Millisecond)
3172 // Send modified requst, this time with e2 subscriptions.
3173 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3174 params2.SetSubscriptionID(&restSubId)
3176 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3177 xappConn1.ExpectAnyNotification(t)
3178 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3179 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3180 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3181 assert.Equal(t, e2SubsId, e2SubsId1)
3183 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3185 xappConn1.DecrementRequestCount()
3186 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3187 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3188 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3189 assert.NotEqual(t, e2SubsId2, 0)
3191 <-time.After(100 * time.Millisecond)
3193 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3194 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3195 params.SetSubscriptionID(&restSubId)
3196 xappConn1.ExpectAnyNotification(t)
3197 // Resend the original request again with only one e2 subscription (detail), this time with restsubsid
3198 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3199 assert.Equal(t, restSubId_resend, restSubId_resend2)
3201 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3202 assert.Equal(t, e2SubsId, e2SubsId1)
3204 // Delete both e2 subscriptions
3205 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3206 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3207 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3209 waitSubsCleanup(t, e2SubsId, 10)
3211 //Wait that subs is cleaned
3212 mainCtrl.VerifyCounterValues(t)
3213 //mainCtrl.VerifyAllClean(t)
3216 //-----------------------------------------------------------------------------
3218 // +-------+ +---------+ +---------+ +---------+
3219 // | xapp | | submgr | | e2term | | rtmgr |
3220 // +-------+ +---------+ +---------+ +---------+
3222 // | RESTSubReq | | |
3223 // |---------------->| | |
3224 // | RESTSubResp | | |
3225 // |<----------------| | |
3226 // | | RouteCreate | |
3227 // | |--------------------------->|
3228 // | | RouteResponse| |
3229 // | |<---------------------------|
3231 // | |------------->| |
3233 // | |<-------------| |
3234 // | RESTNotif1 | | |
3235 // |<----------------| | |
3236 // | RESTSubReq | | |
3237 // | [with RestSUbsId + one additional e2 subDetail]
3238 // |---------------->| | |
3239 // | RESTNotif1 | | |
3240 // | [for initial e2 subDetail] | |
3241 // |<----------------| | |
3242 // | | RouteCreate | |
3243 // | |--------------------------->|
3244 // | | RouteResponse| |
3245 // | |<---------------------------|
3247 // | |------------->| |
3249 // | |<-------------| |
3250 // | RESTNotif1 | | |
3251 // |<----------------| | |
3252 // | RESTSubReq | | |
3253 // | [without RESTsubsId initial request] |
3254 // |---------------->| | |
3255 // | RESTNotif1 | | |
3256 // |<----------------| | |
3257 // | RESTSubDelReq | | |
3258 // |---------------->| | |
3259 // | RESTSubDelResp| | |
3260 // |<----------------| | |
3261 // | | SubDelReq | |
3262 // | |------------->| |
3263 // | | SubDelResp | |
3264 // | |<-------------| |
3265 // | | SubDelReq | |
3266 // | |------------->| |
3267 // | | SubDelResp | |
3268 // | |<-------------| |
3271 //-----------------------------------------------------------------------------
3273 func TestRESTSubReqRetransmissionV5(t *testing.T) {
3274 CaseBegin("TestRESTSubReqRetransmissionV5")
3276 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3277 Counter{cRestSubReqFromXapp, 3},
3278 Counter{cDuplicateE2SubReq, 2},
3279 Counter{cRestSubRespToXapp, 3},
3280 Counter{cSubReqToE2, 2},
3281 Counter{cSubRespFromE2, 2},
3282 Counter{cRestSubNotifToXapp, 4},
3283 Counter{cRestSubDelReqFromXapp, 1},
3284 Counter{cSubDelReqToE2, 2},
3285 Counter{cSubDelRespFromE2, 2},
3286 Counter{cRestSubDelRespToXapp, 1},
3289 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3291 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3293 <-time.After(100 * time.Millisecond)
3295 // Send modified requst, this time with e2 subscriptions.
3296 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3297 params2.SetSubscriptionID(&restSubId)
3299 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3300 xappConn1.ExpectAnyNotification(t)
3301 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3302 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3304 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3305 assert.Equal(t, e2SubsId, e2SubsId1)
3306 // The first E2 subscription returns immediately, manually decrement expected request count for the remaining request handling
3307 xappConn1.DecrementRequestCount()
3309 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3311 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3312 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3313 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3314 assert.NotEqual(t, e2SubsId2, 0)
3316 <-time.After(100 * time.Millisecond)
3318 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3319 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3320 xappConn1.ExpectAnyNotification(t)
3321 // Resend the original request again with only one e2 subscription (detail), WITHOUT restsubsid
3322 // md5sum shall find the original request
3323 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3324 assert.Equal(t, restSubId_resend, restSubId_resend2)
3326 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3327 assert.Equal(t, e2SubsId, e2SubsId1)
3329 // Delete both e2 subscriptions
3330 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3331 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3332 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3334 waitSubsCleanup(t, e2SubsId, 10)
3336 //Wait that subs is cleaned
3337 mainCtrl.VerifyCounterValues(t)
3338 //mainCtrl.VerifyAllClean(t)
3341 //-----------------------------------------------------------------------------
3343 // +-------+ +---------+ +---------+ +---------+
3344 // | xapp | | submgr | | e2term | | rtmgr |
3345 // +-------+ +---------+ +---------+ +---------+
3347 // | RESTSubReq | | |
3348 // |---------------->| | |
3349 // | RESTSubResp | | |
3350 // |<----------------| | |
3351 // | | RouteCreate | |
3352 // | |--------------------------->|
3353 // | | RouteResponse| |
3354 // | |<---------------------------|
3356 // | |------------->| |
3358 // | |<-------------| |
3359 // | RESTNotif1 | | |
3360 // |<----------------| | |
3361 // | RESTSubReq | | |
3362 // | [with RestSUbsId + one additional e2 subDetail]
3363 // |---------------->| | |
3364 // | RESTNotif1 | | |
3365 // | [for initial e2 subDetail] | |
3366 // |<----------------| | |
3367 // | | RouteCreate | |
3368 // | |--------------------------->|
3369 // | | RouteResponse| |
3370 // | |<---------------------------|
3372 // | |------------->| |
3374 // | |<-------------| |
3375 // | RESTNotif1 | | |
3376 // |<----------------| | |
3377 // | RESTSubDelReq | | |
3378 // |---------------->| | |
3379 // | RESTSubDelResp| | |
3380 // |<----------------| | |
3381 // | | SubDelReq | |
3382 // | |------------->| |
3383 // | | SubDelResp | |
3384 // | |<-------------| |
3385 // | | SubDelReq | |
3386 // | |------------->| |
3387 // | | SubDelResp | |
3388 // | |<-------------| |
3389 // | RESTSubReq | | |
3390 // | [with RESTsubsId initial request] |
3391 // |---------------->| | |
3392 // | RESTSubResp | | |
3393 // |<----------------| | |
3394 // | | RouteCreate | |
3395 // | |--------------------------->|
3396 // | | RouteResponse| |
3397 // | |<---------------------------|
3399 // | |------------->| |
3401 // | |<-------------| |
3402 // | RESTNotif1 | | |
3403 // |<----------------| | |
3406 //-----------------------------------------------------------------------------
3407 func TestRESTSubReqRetransmissionV6(t *testing.T) {
3408 CaseBegin("TestRESTSubReqRetransmissionV6")
3410 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3411 Counter{cRestSubReqFromXapp, 3},
3412 Counter{cDuplicateE2SubReq, 1},
3413 Counter{cRestSubRespToXapp, 3},
3414 Counter{cSubReqToE2, 3},
3415 Counter{cSubRespFromE2, 3},
3416 Counter{cRestSubNotifToXapp, 4},
3417 Counter{cRestSubDelReqFromXapp, 2},
3418 Counter{cSubDelReqToE2, 3},
3419 Counter{cSubDelRespFromE2, 3},
3420 Counter{cRestSubDelRespToXapp, 2},
3423 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3425 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3427 <-time.After(100 * time.Millisecond)
3429 // Send modified requst, this time with e2 subscriptions.
3430 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3431 params2.SetSubscriptionID(&restSubId)
3433 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3434 xappConn1.ExpectAnyNotification(t)
3435 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3436 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3438 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3439 assert.Equal(t, e2SubsId, e2SubsId1)
3441 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3443 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3444 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3445 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3446 assert.NotEqual(t, e2SubsId2, 0)
3448 <-time.After(100 * time.Millisecond)
3450 // Delete both e2 subscriptions
3451 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3452 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3453 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3455 waitSubsCleanup(t, e2SubsId, 10)
3457 // Resend the original request, we shall find it's previous md5sum/restsubs
3458 // but the restsubscription has been already removed. This shall trigger a
3460 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
3462 <-time.After(100 * time.Millisecond)
3464 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3466 waitSubsCleanup(t, e2SubsId, 10)
3468 //Wait that subs is cleaned
3469 mainCtrl.VerifyCounterValues(t)
3470 //mainCtrl.VerifyAllClean(t)
3473 func TestRESTSubDelReqRetransmission(t *testing.T) {
3474 CaseBegin("TestRESTSubDelReqRetransmission")
3476 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3477 Counter{cRestSubReqFromXapp, 1},
3478 Counter{cRestSubRespToXapp, 1},
3479 Counter{cSubReqToE2, 1},
3480 Counter{cSubRespFromE2, 1},
3481 Counter{cRestSubNotifToXapp, 1},
3482 Counter{cRestSubDelReqFromXapp, 2},
3483 Counter{cSubDelReqToE2, 1},
3484 Counter{cSubDelRespFromE2, 1},
3485 Counter{cRestSubDelRespToXapp, 2},
3488 var params *teststube2ap.RESTSubsReqParams = nil
3491 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3493 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3496 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3497 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3499 seqBef := mainCtrl.get_msgcounter(t)
3500 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3501 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
3503 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3505 waitSubsCleanup(t, e2SubsId, 10)
3507 mainCtrl.VerifyCounterValues(t)
3508 //mainCtrl.VerifyAllClean(t)
3511 //-----------------------------------------------------------------------------
3512 // TestRESTSubReqDelReq
3515 // +-------+ +---------+ +---------+
3516 // | xapp | | submgr | | e2term |
3517 // +-------+ +---------+ +---------+
3520 // |---------------->| |
3522 // | RESTSubResp | |
3523 // |<----------------| |
3525 // | |------------->|
3526 // | RESTSubDelReq | |
3527 // |---------------->| |
3528 // | RESTSubDelResp | |
3530 // |<----------------| |
3532 // | |<-------------|
3534 // |<----------------| |
3536 // | [SUBS DELETE] |
3539 //-----------------------------------------------------------------------------
3540 func TestRESTSubReqDelReq(t *testing.T) {
3541 CaseBegin("TestRESTSubReqDelReq")
3543 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3544 Counter{cRestSubReqFromXapp, 1},
3545 Counter{cRestSubRespToXapp, 1},
3546 Counter{cSubReqToE2, 1},
3547 Counter{cSubRespFromE2, 1},
3548 Counter{cRestSubNotifToXapp, 1},
3549 Counter{cRestSubDelReqFromXapp, 2},
3550 Counter{cRestSubDelFailToXapp, 1},
3551 Counter{cSubDelReqToE2, 1},
3552 Counter{cSubDelRespFromE2, 1},
3553 Counter{cRestSubDelRespToXapp, 1},
3556 const subReqCount int = 1
3559 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3560 restSubId := xappConn1.SendRESTSubsReq(t, params)
3562 // Del. This will fail as processing of the subscription
3563 // is still ongoing in submgr. Deletion is not allowed before
3564 // subscription creation has been completed.
3565 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3566 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3567 xappConn1.ExpectRESTNotification(t, restSubId)
3568 e2termConn1.SendSubsResp(t, crereq, cremsg)
3569 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3572 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3574 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3575 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3577 // Wait that subs is cleaned
3578 waitSubsCleanup(t, e2SubsId, 10)
3579 mainCtrl.VerifyCounterValues(t)
3580 //mainCtrl.VerifyAllClean(t)
3583 func TestRESTSubDelReqCollision(t *testing.T) {
3584 CaseBegin("TestRESTSubDelReqCollision - not relevant for REST API")
3587 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
3588 CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel")
3590 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3591 Counter{cRestSubReqFromXapp, 2},
3592 Counter{cRestSubRespToXapp, 2},
3593 Counter{cSubReqToE2, 2},
3594 Counter{cSubRespFromE2, 2},
3595 Counter{cRestSubNotifToXapp, 2},
3596 Counter{cRestSubDelReqFromXapp, 2},
3597 Counter{cSubDelReqToE2, 2},
3598 Counter{cSubDelRespFromE2, 2},
3599 Counter{cRestSubDelRespToXapp, 2},
3603 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3604 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3605 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3608 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3609 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3610 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3612 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3613 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3615 //XappConn1 receives both of the responses
3616 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3619 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3621 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3623 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3624 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3625 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3626 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3629 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3631 deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
3633 //Wait that subs is cleaned
3634 mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
3635 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
3637 mainCtrl.VerifyCounterValues(t)
3638 //mainCtrl.VerifyAllClean(t)
3641 func TestRESTSameSubsDiffRan(t *testing.T) {
3642 CaseBegin("TestRESTSameSubsDiffRan")
3644 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3645 Counter{cRestSubReqFromXapp, 2},
3646 Counter{cRestSubRespToXapp, 2},
3647 Counter{cSubReqToE2, 2},
3648 Counter{cSubRespFromE2, 2},
3649 Counter{cRestSubNotifToXapp, 2},
3650 Counter{cRestSubDelReqFromXapp, 2},
3651 Counter{cSubDelReqToE2, 2},
3652 Counter{cSubDelRespFromE2, 2},
3653 Counter{cRestSubDelRespToXapp, 2},
3656 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3657 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3658 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3660 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3661 params.SetMeid("RAN_NAME_2")
3662 restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
3663 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3666 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3668 deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
3670 //Wait that subs is cleaned
3671 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3672 waitSubsCleanup(t, e2SubsId2, 10)
3674 mainCtrl.VerifyCounterValues(t)
3675 //mainCtrl.VerifyAllClean(t)
3678 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
3679 CaseBegin("TestRESTSubReqRetryInSubmgr start")
3681 // Init counter check
3682 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3683 Counter{cRestSubReqFromXapp, 1},
3684 Counter{cRestSubRespToXapp, 1},
3685 Counter{cSubReqToE2, 1},
3686 Counter{cSubReqTimerExpiry, 1},
3687 Counter{cSubReReqToE2, 1},
3688 Counter{cSubRespFromE2, 1},
3689 Counter{cRestSubNotifToXapp, 1},
3690 Counter{cRestSubDelReqFromXapp, 1},
3691 Counter{cSubDelReqToE2, 1},
3692 Counter{cSubDelRespFromE2, 1},
3693 Counter{cRestSubDelRespToXapp, 1},
3696 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3697 restSubId := xappConn1.SendRESTSubsReq(t, params)
3699 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3701 // Catch the first message and ignore it
3702 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3703 xapp.Logger.Debug("Ignore REST subscriber request for subscriber : %v", restSubId)
3705 // The second request is being handled normally
3706 crereq, cremsg = e2termConn1.RecvSubsReq(t)
3707 xappConn1.ExpectRESTNotification(t, restSubId)
3708 e2termConn1.SendSubsResp(t, crereq, cremsg)
3709 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3711 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3713 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3715 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
3716 //Wait that subs is cleaned
3717 waitSubsCleanup(t, e2SubsId, 10)
3719 mainCtrl.VerifyCounterValues(t)
3720 //mainCtrl.VerifyAllClean(t)
3723 //-----------------------------------------------------------------------------
3724 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3727 // +-------+ +---------+ +---------+
3728 // | xapp | | submgr | | e2term |
3729 // +-------+ +---------+ +---------+
3732 // |---------------->| |
3734 // | RESTSubResp | |
3735 // |<----------------| |
3737 // | |------------->|
3741 // | |------------->|
3744 // | |------------->|
3748 // | |------------->|
3752 // | |<-------------|
3755 // |<----------------| |
3757 // | [SUBS DELETE] |
3760 //-----------------------------------------------------------------------------
3762 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
3763 CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
3765 // Init counter check
3766 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3767 Counter{cRestSubReqFromXapp, 1},
3768 Counter{cRestSubRespToXapp, 1},
3769 Counter{cSubReqToE2, 1},
3770 Counter{cSubReReqToE2, 1},
3771 Counter{cSubReqTimerExpiry, 2},
3772 Counter{cRestSubFailNotifToXapp, 1},
3773 Counter{cSubDelReqToE2, 1},
3774 Counter{cSubDelRespFromE2, 1},
3776 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3777 restSubId := xappConn1.SendRESTSubsReq(t, params)
3778 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3780 e2termConn1.RecvSubsReq(t)
3781 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3783 e2termConn1.RecvSubsReq(t)
3784 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3786 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3787 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3788 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3789 xappConn1.WaitRESTNotification(t, restSubId)
3791 // Wait that subs is cleaned
3792 waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
3794 mainCtrl.VerifyCounterValues(t)
3795 //mainCtrl.VerifyAllClean(t)
3798 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
3799 CaseBegin("TestREST2eTermNotRespondingToSubReq start")
3801 // Init counter check
3802 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3803 Counter{cRestSubReqFromXapp, 1},
3804 Counter{cRestSubRespToXapp, 1},
3805 Counter{cSubReqToE2, 1},
3806 Counter{cSubReReqToE2, 1},
3807 Counter{cSubReqTimerExpiry, 2},
3808 Counter{cSubDelReReqToE2, 1},
3809 Counter{cRestSubFailNotifToXapp, 1},
3810 Counter{cSubDelReqToE2, 1},
3811 Counter{cSubDelReqTimerExpiry, 2},
3813 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3814 restSubId := xappConn1.SendRESTSubsReq(t, params)
3815 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3817 e2termConn1.RecvSubsReq(t)
3818 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3820 e2termConn1.RecvSubsReq(t)
3821 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3823 e2termConn1.RecvSubsDelReq(t)
3824 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3826 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3827 e2termConn1.RecvSubsDelReq(t)
3828 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3830 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3832 waitSubsCleanup(t, e2SubsId, 10)
3834 mainCtrl.VerifyCounterValues(t)
3835 //mainCtrl.VerifyAllClean(t)
3838 //-----------------------------------------------------------------------------
3839 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3842 // +-------+ +---------+ +---------+
3843 // | xapp | | submgr | | e2term |
3844 // +-------+ +---------+ +---------+
3847 // |---------------->| |
3849 // | RESTSubResp | |
3850 // |<----------------| |
3852 // | |------------->|
3856 // | |------------->|
3859 // | |------------->|
3863 // | |------------->|
3867 // | |<-------------|
3870 // |<----------------| |
3872 // | [SUBS DELETE] |
3875 //-----------------------------------------------------------------------------
3876 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
3877 CaseBegin("TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr start")
3879 // Init counter check
3880 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3881 Counter{cRestSubReqFromXapp, 1},
3882 Counter{cRestSubRespToXapp, 1},
3883 Counter{cSubReqToE2, 1},
3884 Counter{cSubReReqToE2, 1},
3885 Counter{cSubReqTimerExpiry, 2},
3886 Counter{cRestSubFailNotifToXapp, 1},
3887 Counter{cSubDelReqToE2, 1},
3888 Counter{cSubDelReReqToE2, 1},
3889 Counter{cSubDelReqTimerExpiry, 2},
3892 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3893 restSubId := xappConn1.SendRESTSubsReq(t, params)
3894 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3896 e2termConn1.RecvSubsReq(t)
3897 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3899 e2termConn1.RecvSubsReq(t)
3900 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3902 e2termConn1.RecvSubsDelReq(t)
3903 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3905 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3906 e2termConn1.RecvSubsDelReq(t)
3907 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3909 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3911 waitSubsCleanup(t, e2SubsId, 10)
3913 mainCtrl.VerifyCounterValues(t)
3914 //mainCtrl.VerifyAllClean(t)
3917 //-----------------------------------------------------------------------------
3918 // TestRESTSubReqSubFailRespInSubmgr
3921 // +-------+ +---------+ +---------+
3922 // | xapp | | submgr | | e2term |
3923 // +-------+ +---------+ +---------+
3926 // |---------------->| |
3928 // | RESTSubResp | |
3929 // |<----------------| |
3931 // | |------------->|
3934 // | |<-------------|
3938 // |<----------------| |
3940 // | [SUBS DELETE] |
3943 //-----------------------------------------------------------------------------
3944 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
3945 CaseBegin("TestRESTSubReqSubFailRespInSubmgr")
3947 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3948 Counter{cRestSubReqFromXapp, 1},
3949 Counter{cRestSubRespToXapp, 1},
3950 Counter{cSubReqToE2, 1},
3951 Counter{cSubFailFromE2, 1},
3952 Counter{cRestSubFailNotifToXapp, 1},
3953 Counter{cRestSubDelReqFromXapp, 1},
3954 Counter{cRestSubDelRespToXapp, 1},
3957 const subReqCount int = 1
3958 const e2Timeout int64 = 2
3959 const e2RetryCount int64 = 1
3960 const routingNeeded bool = true
3962 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3963 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
3964 restSubId := xappConn1.SendRESTSubsReq(t, params)
3966 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3967 fparams1 := &teststube2ap.E2StubSubsFailParams{}
3968 fparams1.Set(crereq1)
3969 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3970 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3972 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3973 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
3975 // REST subscription sill there to be deleted
3976 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3978 // Wait that subs is cleaned
3979 waitSubsCleanup(t, e2SubsId, 10)
3981 mainCtrl.VerifyCounterValues(t)
3982 //mainCtrl.VerifyAllClean(t)
3985 //-----------------------------------------------------------------------------
3986 // TestRESTSubDelReqRetryInSubmgr
3989 // +-------+ +---------+ +---------+
3990 // | xapp | | submgr | | e2term |
3991 // +-------+ +---------+ +---------+
3993 // | [SUBS CREATE] |
3996 // | RESTSubDelReq | |
3997 // |---------------->| |
3999 // | RESTSubDelResp | |
4000 // |<----------------| |
4002 // | |------------->|
4005 // | |------------->|
4008 // | |<-------------|
4011 //-----------------------------------------------------------------------------
4012 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
4013 CaseBegin("TestRESTSubDelReqRetryInSubmgr")
4015 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4016 Counter{cRestSubReqFromXapp, 1},
4017 Counter{cRestSubRespToXapp, 1},
4018 Counter{cSubReqToE2, 1},
4019 Counter{cSubRespFromE2, 1},
4020 Counter{cRestSubNotifToXapp, 1},
4021 Counter{cRestSubDelReqFromXapp, 1},
4022 Counter{cSubDelReqToE2, 1},
4023 Counter{cSubDelReqTimerExpiry, 1},
4024 Counter{cSubDelReReqToE2, 1},
4025 Counter{cSubDelRespFromE2, 1},
4026 Counter{cRestSubDelRespToXapp, 1},
4029 var params *teststube2ap.RESTSubsReqParams = nil
4030 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4033 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4035 // E2t: Receive 1st SubsDelReq
4036 e2termConn1.RecvSubsDelReq(t)
4038 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4039 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4040 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4042 //Wait that subs is cleaned
4043 waitSubsCleanup(t, e2SubsId, 10)
4045 mainCtrl.VerifyCounterValues(t)
4046 //mainCtrl.VerifyAllClean(t)
4049 //-----------------------------------------------------------------------------
4050 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
4053 // +-------+ +---------+ +---------+
4054 // | xapp | | submgr | | e2term |
4055 // +-------+ +---------+ +---------+
4057 // | [SUBS CREATE] |
4060 // | RESTSubDelReq | |
4061 // |---------------->| |
4063 // | RESTSubDelResp | |
4064 // |<----------------| |
4066 // | |------------->|
4069 // | |------------->|
4073 //-----------------------------------------------------------------------------
4074 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
4075 CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr")
4077 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4078 Counter{cRestSubReqFromXapp, 1},
4079 Counter{cRestSubRespToXapp, 1},
4080 Counter{cSubReqToE2, 1},
4081 Counter{cSubRespFromE2, 1},
4082 Counter{cRestSubNotifToXapp, 1},
4083 Counter{cRestSubDelReqFromXapp, 1},
4084 Counter{cSubDelReqToE2, 1},
4085 Counter{cSubDelReqTimerExpiry, 1},
4086 Counter{cSubDelReReqToE2, 1},
4087 Counter{cSubDelRespFromE2, 1},
4088 Counter{cRestSubDelRespToXapp, 1},
4092 var params *teststube2ap.RESTSubsReqParams = nil
4093 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4096 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4098 // E2t: Receive 1st SubsDelReq
4099 e2termConn1.RecvSubsDelReq(t)
4101 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4102 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4103 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4105 //Wait that subs is cleaned
4106 waitSubsCleanup(t, e2SubsId, 10)
4108 mainCtrl.VerifyCounterValues(t)
4109 //mainCtrl.VerifyAllClean(t)
4112 //-----------------------------------------------------------------------------
4113 // TestRESTSubDelReqSubDelFailRespInSubmgr
4116 // +-------+ +---------+ +---------+
4117 // | xapp | | submgr | | e2term |
4118 // +-------+ +---------+ +---------+
4120 // | [SUBS CREATE] |
4123 // | RESTSubDelReq | |
4124 // |---------------->| |
4126 // | RESTSubDelResp | |
4127 // |<----------------| |
4129 // | |------------->|
4132 // | |<-------------|
4135 //-----------------------------------------------------------------------------
4136 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
4137 CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr")
4139 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4140 Counter{cRestSubReqFromXapp, 1},
4141 Counter{cRestSubRespToXapp, 1},
4142 Counter{cSubReqToE2, 1},
4143 Counter{cSubRespFromE2, 1},
4144 Counter{cRestSubNotifToXapp, 1},
4145 Counter{cRestSubDelReqFromXapp, 1},
4146 Counter{cSubDelReqToE2, 1},
4147 Counter{cSubDelFailFromE2, 1},
4148 Counter{cRestSubDelRespToXapp, 1},
4152 var params *teststube2ap.RESTSubsReqParams = nil
4153 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4156 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4158 // E2t: Send receive SubsDelReq and send SubsDelFail
4159 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4160 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
4162 //Wait that subs is cleaned
4163 waitSubsCleanup(t, e2SubsId, 10)
4165 mainCtrl.VerifyCounterValues(t)
4166 //mainCtrl.VerifyAllClean(t)
4169 //-----------------------------------------------------------------------------
4170 // TestRESTSubReqAndSubDelOkSameAction
4173 // +-------+ +-------+ +---------+ +---------+
4174 // | xapp2 | | xapp1 | | submgr | | e2term |
4175 // +-------+ +-------+ +---------+ +---------+
4177 // | | RESTSubReq1 | |
4178 // | |---------------->| |
4180 // | | RESTSubResp1 | |
4181 // | |<----------------| |
4184 // | | |------------->|
4186 // | | |<-------------|
4187 // | | RESTNotif1 | |
4188 // | |<----------------| |
4190 // | RESTSubReq2 | |
4191 // |------------------------------>| |
4193 // | RESTSubResp2 | |
4194 // |<------------------------------| |
4196 // | | RESTNotif2 | |
4197 // |<------------------------------| |
4199 // | | RESTSubDelReq1 | |
4200 // | |---------------->| |
4202 // | | RESTSubDelResp1 | |
4203 // | |<----------------| |
4205 // | RESTSubDelReq2 | |
4206 // |------------------------------>| |
4208 // | RESTSubDelResp2 | |
4209 // |<------------------------------| |
4211 // | | | SubDelReq2 |
4212 // | | |------------->|
4214 // | | | SubDelResp2 |
4215 // | | |<-------------|
4218 //-----------------------------------------------------------------------------
4219 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
4220 CaseBegin("TestRESTSubReqAndSubDelOkSameAction")
4222 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4223 Counter{cRestSubReqFromXapp, 2},
4224 Counter{cRestSubRespToXapp, 2},
4225 Counter{cSubReqToE2, 1},
4226 Counter{cSubRespFromE2, 1},
4227 Counter{cRestSubNotifToXapp, 2},
4228 Counter{cMergedSubscriptions, 1},
4229 Counter{cUnmergedSubscriptions, 1},
4230 Counter{cRestSubDelReqFromXapp, 2},
4231 Counter{cSubDelReqToE2, 1},
4232 Counter{cSubDelRespFromE2, 1},
4233 Counter{cRestSubDelRespToXapp, 2},
4237 var params *teststube2ap.RESTSubsReqParams = nil
4240 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4241 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4244 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4245 params.SetMeid("RAN_NAME_1")
4247 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4248 xappConn2.ExpectAnyNotification(t)
4249 waiter := rtmgrHttp.AllocNextSleep(10, true)
4250 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4251 waiter.WaitResult(t)
4252 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
4253 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
4254 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
4256 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
4259 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4262 deleteXapp2Subscription(t, &restSubId2)
4264 //Wait that subs is cleaned
4265 waitSubsCleanup(t, e2SubsId2, 10)
4267 mainCtrl.VerifyCounterValues(t)
4268 //mainCtrl.VerifyAllClean(t)
4271 //-----------------------------------------------------------------------------
4272 // TestSubReqAndSubDelOkSameActionParallel
4275 // +-------+ +-------+ +---------+ +---------+
4276 // | xapp2 | | xapp1 | | submgr | | e2term |
4277 // +-------+ +-------+ +---------+ +---------+
4282 // | |------------->| |
4285 // | | |------------->|
4287 // |--------------------------->| |
4289 // | | |<-------------|
4291 // | |<-------------| |
4293 // | | |------------->|
4296 // | | |<-------------|
4298 // |<---------------------------| |
4300 // | | SubDelReq 1 | |
4301 // | |------------->| |
4303 // | | SubDelResp 1 | |
4304 // | |<-------------| |
4306 // | SubDelReq 2 | |
4307 // |--------------------------->| |
4309 // | | | SubDelReq 2 |
4310 // | | |------------->|
4312 // | | | SubDelReq 2 |
4313 // | | |------------->|
4315 // | SubDelResp 2 | |
4316 // |<---------------------------| |
4318 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
4319 CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel")
4321 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4322 Counter{cRestSubReqFromXapp, 2},
4323 Counter{cRestSubRespToXapp, 2},
4324 Counter{cSubReqToE2, 2},
4325 Counter{cSubRespFromE2, 2},
4326 Counter{cRestSubNotifToXapp, 2},
4327 Counter{cRestSubDelReqFromXapp, 2},
4328 Counter{cSubDelReqToE2, 2},
4329 Counter{cSubDelRespFromE2, 2},
4330 Counter{cRestSubDelRespToXapp, 2},
4333 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4334 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4335 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4337 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4338 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4340 xappConn1.ExpectRESTNotification(t, restSubId1)
4341 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4342 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4344 xappConn2.ExpectRESTNotification(t, restSubId2)
4345 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
4346 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
4347 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4350 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4351 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4352 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4353 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4356 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4357 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
4358 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
4360 waitSubsCleanup(t, e2SubsId2, 10)
4362 mainCtrl.VerifyCounterValues(t)
4363 //mainCtrl.VerifyAllClean(t)
4366 //-----------------------------------------------------------------------------
4367 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
4370 // +-------+ +-------+ +---------+ +---------+
4371 // | xapp2 | | xapp1 | | submgr | | e2term |
4372 // +-------+ +-------+ +---------+ +---------+
4376 // | | RESTSubReq1 | |
4377 // | |---------------->| |
4379 // | | RESTSubResp1 | |
4380 // | |<----------------| |
4382 // | | |------------->|
4383 // | RESTSubReq2 | |
4384 // |------------------------------>| |
4386 // | RESTSubResp2 | |
4387 // |<------------------------------| |
4389 // | | |------------->|
4392 // | | | SubDelReq |
4393 // | | |------------->|
4395 // | | | SubDelResp |
4396 // | | |<-------------|
4397 // | | RESTNotif1 | |
4398 // | | unsuccess | |
4399 // | |<----------------| |
4401 // | | unsuccess | |
4402 // |<------------------------------| |
4404 // | | RESTSubDelReq1 | |
4405 // | |---------------->| |
4407 // | | RESTSubDelResp1 | |
4408 // | |<----------------| |
4410 // | RESTSubDelReq2 | |
4411 // |------------------------------>| |
4413 // | RESTSubDelResp2 | |
4414 // |<------------------------------| |
4416 //-----------------------------------------------------------------------------
4417 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
4418 CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
4420 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4421 Counter{cRestSubReqFromXapp, 2},
4422 Counter{cMergedSubscriptions, 1},
4423 Counter{cRestSubRespToXapp, 2},
4424 Counter{cSubReqToE2, 1},
4425 Counter{cSubReqTimerExpiry, 2},
4426 Counter{cSubReReqToE2, 1},
4427 Counter{cRestSubFailNotifToXapp, 2},
4428 Counter{cRestSubDelReqFromXapp, 2},
4429 Counter{cSubDelReqToE2, 1},
4430 Counter{cSubDelRespFromE2, 1},
4431 Counter{cRestSubDelRespToXapp, 2},
4433 const subReqCount int = 1
4436 params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4437 restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
4438 crereq1, _ := e2termConn1.RecvSubsReq(t)
4441 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4442 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4443 params2.SetMeid("RAN_NAME_1")
4444 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4445 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4447 //Req1 (retransmitted)
4448 e2termConn1.RecvSubsReq(t)
4450 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4452 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4453 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4455 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4456 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4457 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4458 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4461 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4464 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4466 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
4468 //Wait that subs is cleaned
4469 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4471 mainCtrl.VerifyCounterValues(t)
4472 //mainCtrl.VerifyAllClean(t)
4475 //-----------------------------------------------------------------------------
4476 // TestRESTSubReqAndSubDelNokSameActionParallel
4479 // +-------+ +-------+ +---------+ +---------+
4480 // | xapp2 | | xapp1 | | submgr | | e2term |
4481 // +-------+ +-------+ +---------+ +---------+
4485 // | | RESTSubReq1 | |
4486 // | |---------------->| |
4488 // | | RESTSubResp1 | |
4489 // | |<----------------| |
4491 // | | |------------->|
4492 // | RESTSubReq2 | |
4493 // |------------------------------>| |
4495 // | RESTSubDelResp2 | |
4496 // |<------------------------------| |
4498 // | | |<-------------|
4500 // | | RESTNotif1 | |
4501 // | | unsuccess | |
4502 // | |<----------------| |
4504 // | | unsuccess | |
4505 // |<------------------------------| |
4507 // | | RESTSubDelReq1 | | There is no need for xApp to send delete for failed subscriptions but some xApp might do so.
4508 // | |---------------->| |
4510 // | | RESTSubDelResp1 | |
4511 // | |<----------------| |
4513 // | RESTSubDelReq2 | |
4514 // |------------------------------>| |
4516 // | RESTSubDelResp2 | |
4517 // |<------------------------------| |
4519 //-----------------------------------------------------------------------------
4520 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
4521 CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
4523 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4524 Counter{cRestSubReqFromXapp, 2},
4525 Counter{cMergedSubscriptions, 1},
4526 Counter{cRestSubRespToXapp, 2},
4527 Counter{cSubReqToE2, 1},
4528 Counter{cSubFailFromE2, 1},
4529 Counter{cRestSubFailNotifToXapp, 2},
4530 Counter{cRestSubDelReqFromXapp, 2},
4531 Counter{cRestSubDelRespToXapp, 2},
4534 const subReqCount int = 1
4537 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4538 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4539 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4542 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4543 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4544 params2.SetMeid("RAN_NAME_1")
4545 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4546 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4548 // E2t: send SubsFail (first)
4549 fparams1 := &teststube2ap.E2StubSubsFailParams{}
4550 fparams1.Set(crereq1)
4551 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
4553 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4554 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4555 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4556 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4557 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4560 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4563 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4565 //Wait that subs is cleaned
4566 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4567 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
4569 mainCtrl.VerifyCounterValues(t)
4570 //mainCtrl.VerifyAllClean(t)
4573 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
4574 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4576 // Init counter check
4577 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4578 Counter{cRestSubReqFromXapp, 1},
4579 Counter{cRestSubRespToXapp, 1},
4580 Counter{cSubReqToE2, 1},
4581 Counter{cSubRespFromE2, 1},
4582 Counter{cRestSubNotifToXapp, 1},
4583 Counter{cRestSubDelReqFromXapp, 1},
4584 Counter{cSubDelReqToE2, 1},
4585 Counter{cSubDelRespFromE2, 1},
4586 Counter{cRestSubDelRespToXapp, 1},
4589 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4590 restSubId := xappConn1.SendRESTSubsReq(t, params)
4591 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
4593 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4594 xappConn1.ExpectRESTNotification(t, restSubId)
4595 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4596 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4597 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
4599 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4600 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4601 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4603 // Wait that subs is cleaned
4604 waitSubsCleanup(t, e2SubsId, 10)
4605 mainCtrl.VerifyCounterValues(t)
4606 //mainCtrl.VerifyAllClean(t)
4609 //-----------------------------------------------------------------------------
4610 // TestRESTSubReqPolicyChangeAndSubDelOk
4613 // +-------+ +---------+ +---------+
4614 // | xapp | | submgr | | e2term |
4615 // +-------+ +---------+ +---------+
4618 // |---------------->| |
4620 // | RESTSubResp | |
4621 // |<----------------| |
4623 // | |------------->|
4626 // | |<-------------|
4629 // |<----------------| |
4632 // |---------------->| |
4634 // | RESTSubResp | |
4635 // |<----------------| |
4637 // | |------------->|
4640 // | |<-------------|
4643 // |<----------------| |
4645 // | RESTSubDelReq | |
4646 // |---------------->| |
4649 // | |------------->|
4652 // | |<-------------|
4654 // | RESTSubDelResp | |
4655 // |<----------------| |
4657 //-----------------------------------------------------------------------------
4658 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
4659 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4661 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4662 Counter{cRestSubReqFromXapp, 2},
4663 Counter{cRestSubRespToXapp, 2},
4664 Counter{cSubReqToE2, 2},
4665 Counter{cSubRespFromE2, 2},
4666 Counter{cRestSubNotifToXapp, 2},
4667 Counter{cRestSubDelReqFromXapp, 1},
4668 Counter{cSubDelReqToE2, 1},
4669 Counter{cSubDelRespFromE2, 1},
4670 Counter{cRestSubDelRespToXapp, 1},
4673 const subReqCount int = 1
4674 const e2Timeout int64 = 1
4675 const e2RetryCount int64 = 0
4676 const routingNeeded bool = true
4679 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4680 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4681 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4684 // GetRESTSubsReqPolicyParams sets some counters on tc side.
4686 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4687 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4688 params.SetSubscriptionID(&restSubId)
4689 params.SetTimeToWait("w200ms")
4690 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
4693 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4695 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4696 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4698 // Wait that subs is cleaned
4699 waitSubsCleanup(t, e2SubsId, 10)
4700 mainCtrl.VerifyCounterValues(t)
4701 //mainCtrl.VerifyAllClean(t)
4704 //-----------------------------------------------------------------------------
4705 // TestRESTSubReqPolicyChangeNOk
4708 // +-------+ +---------+ +---------+
4709 // | xapp | | submgr | | e2term |
4710 // +-------+ +---------+ +---------+
4713 // |---------------->| |
4715 // | RESTSubResp | |
4716 // |<----------------| |
4718 // | |------------->|
4721 // | |<-------------|
4724 // |<----------------| |
4727 // |---------------->| |
4729 // | RESTSubUpdateFail(400 Bad request)
4731 // | RESTSubDelReq | |
4732 // |---------------->| |
4735 // | |------------->|
4738 // | |<-------------|
4740 // | RESTSubDelResp | |
4741 // |<----------------| |
4743 //-----------------------------------------------------------------------------
4744 func TestRESTSubReqPolicyChangeNOk(t *testing.T) {
4745 CaseBegin("TestRESTSubReqPolicyChangeNOk")
4747 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4748 Counter{cRestSubReqFromXapp, 2},
4749 Counter{cRestSubRespToXapp, 1},
4750 Counter{cSubReqToE2, 1},
4751 Counter{cSubRespFromE2, 1},
4752 Counter{cRestSubNotifToXapp, 1},
4753 Counter{cRestSubFailToXapp, 1},
4754 Counter{cRestSubDelReqFromXapp, 1},
4755 Counter{cSubDelReqToE2, 1},
4756 Counter{cSubDelRespFromE2, 1},
4757 Counter{cRestSubDelRespToXapp, 1},
4761 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4762 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4765 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4767 restSubIdUpd := strings.ToUpper(restSubId) // This makes RESTSubReq to fail
4768 params.SetSubscriptionID(&restSubIdUpd)
4769 params.SetTimeToWait("w200ms")
4771 restSubId2 := xappConn1.SendRESTSubsReq(t, params)
4772 assert.Equal(t, restSubId2, "")
4775 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4777 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4778 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4780 // Wait that subs is cleaned
4781 waitSubsCleanup(t, e2SubsId, 10)
4782 mainCtrl.VerifyCounterValues(t)
4783 //mainCtrl.VerifyAllClean(t)
4786 //-----------------------------------------------------------------------------
4787 // TestRESTSubReqAndSubDelOkTwoE2termParallel
4790 // +-------+ +---------+ +---------+ +---------+
4791 // | xapp | | submgr | | e2term1 | | e2term2 |
4792 // +-------+ +---------+ +---------+ +---------+
4796 // | RESTSubReq1 | | |
4797 // |---------------->| | |
4799 // | RESTSubResp1 | | |
4800 // |<----------------| | |
4802 // | |------------->| |
4804 // | RESTSubReq2 | | |
4805 // |---------------->| | |
4807 // | RESTSubResp2 | | |
4808 // |<----------------| | |
4810 // | |---------------------------->|
4813 // | |<-------------| |
4814 // | RESTNotif1 | | |
4815 // |<----------------| | |
4817 // | |<----------------------------|
4818 // | RESTNotif2 | | |
4819 // |<----------------| | |
4821 // | [SUBS 1 DELETE] | |
4823 // | [SUBS 2 DELETE] | |
4826 //-----------------------------------------------------------------------------
4827 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
4828 CaseBegin("TestRESTSubReqAndSubDelOkTwoE2termParallel")
4830 // Init counter check
4831 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4832 Counter{cRestSubReqFromXapp, 2},
4833 Counter{cRestSubRespToXapp, 2},
4834 Counter{cSubReqToE2, 2},
4835 Counter{cSubRespFromE2, 2},
4836 Counter{cRestSubNotifToXapp, 2},
4837 Counter{cRestSubDelReqFromXapp, 2},
4838 Counter{cSubDelReqToE2, 2},
4839 Counter{cSubDelRespFromE2, 2},
4840 Counter{cRestSubDelRespToXapp, 2},
4843 const subReqCount int = 1
4846 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4847 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4848 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4851 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4852 params.SetMeid("RAN_NAME_11")
4853 // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
4854 // would not work as notification would not be received
4855 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4856 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
4859 xappConn1.ExpectRESTNotification(t, restSubId1)
4860 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4861 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4862 xapp.Logger.Debug("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
4865 xappConn2.ExpectRESTNotification(t, restSubId2)
4866 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
4867 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4868 xapp.Logger.Debug("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
4871 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4872 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4873 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4875 // Wait that subs is cleaned
4876 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4879 xappConn1.SendRESTSubsDelReq(t, &restSubId2)
4880 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
4881 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
4883 // Wait that subs is cleaned
4884 waitSubsCleanup(t, e2SubsId2, 10)
4886 mainCtrl.VerifyCounterValues(t)
4887 //mainCtrl.VerifyAllClean(t)
4890 //-----------------------------------------------------------------------------
4891 // TestRESTSubReqAsn1EncodeFail
4893 // In this case submgr send RICSubscriptionDeleteRequest after encode failure which should not happen!
4895 // +-------+ +---------+ +---------+
4896 // | xapp | | submgr | | e2term |
4897 // +-------+ +---------+ +---------+
4900 // |---------------->| |
4902 // | RESTSubResp | |
4903 // |<----------------| |
4904 // | RESTSubDelReq | |
4905 // |---------------->| |
4906 // | RESTSubDelResp | |
4908 // |<----------------| |
4911 //-----------------------------------------------------------------------------
4912 func TestRESTSubReqAsn1EncodeFail(t *testing.T) {
4913 CaseBegin("TestRESTSubReqAsn1EncodeFail")
4915 xapp.Logger.Debug("Xapp-frame, v0.8.1 sufficient REST API validation")
4919 //-----------------------------------------------------------------------------
4920 // TestRESTSubReqInsertAndSubDelOk
4923 // +-------+ +---------+ +---------+
4924 // | xapp | | submgr | | e2term |
4925 // +-------+ +---------+ +---------+
4928 // |---------------->| |
4930 // | RESTSubResp | |
4931 // |<----------------| |
4934 // | |------------->|
4937 // | |<-------------|
4939 // |<----------------| |
4942 // | RESTSubDelReq | |
4943 // |---------------->| |
4946 // | |------------->|
4949 // | |<-------------|
4951 // | RESTSubDelResp| |
4952 // |<----------------| |
4954 //-----------------------------------------------------------------------------
4955 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
4956 CaseBegin("TestRESTInsertSubReqAndSubDelOk")
4958 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4959 Counter{cRestSubReqFromXapp, 1},
4960 Counter{cRestSubRespToXapp, 1},
4961 Counter{cSubReqToE2, 1},
4962 Counter{cSubRespFromE2, 1},
4963 Counter{cRestSubNotifToXapp, 1},
4964 Counter{cRestSubDelReqFromXapp, 1},
4965 Counter{cSubDelReqToE2, 1},
4966 Counter{cSubDelRespFromE2, 1},
4967 Counter{cRestSubDelRespToXapp, 1},
4970 const subReqCount int = 1
4972 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4973 params.SetSubActionTypes("insert")
4976 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4979 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4981 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4982 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4984 // Wait that subs is cleaned
4985 waitSubsCleanup(t, e2SubsId, 10)
4986 mainCtrl.VerifyCounterValues(t)
4987 //mainCtrl.VerifyAllClean(t)
4990 //-----------------------------------------------------------------------------
4991 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
4994 // +-------+ +---------+ +---------+
4995 // | xapp | | submgr | | e2term |
4996 // +-------+ +---------+ +---------+
4999 // |------------->| |
5002 // | |------------->|
5007 // | Submgr restart |
5011 // | |------------->|
5014 // | |<-------------|
5017 //-----------------------------------------------------------------------------
5018 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
5019 CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle")
5021 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5022 Counter{cRestSubReqFromXapp, 1},
5023 Counter{cRestSubRespToXapp, 1},
5024 Counter{cSubReqToE2, 1},
5025 Counter{cSubDelReqFromXapp, 1},
5026 Counter{cSubDelReqToE2, 1},
5027 Counter{cSubDelRespFromE2, 1},
5028 Counter{cRestSubFailNotifToXapp, 1},
5031 const subReqCount int = 1
5033 // Remove possible existing subscription
5034 mainCtrl.removeExistingSubscriptions(t)
5036 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5039 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
5040 restSubId := xappConn1.SendRESTSubsReq(t, params)
5041 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5043 e2termConn1.RecvSubsReq(t)
5045 mainCtrl.SetResetTestFlag(t, false)
5047 mainCtrl.SimulateRestart(t)
5048 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5051 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5052 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5054 xappConn1.TestMsgChanEmpty(t)
5055 xappConn2.TestMsgChanEmpty(t)
5056 e2termConn1.TestMsgChanEmpty(t)
5057 mainCtrl.wait_registry_empty(t, 10)
5059 mainCtrl.VerifyCounterValues(t)
5060 //mainCtrl.VerifyAllClean(t)
5063 //-----------------------------------------------------------------------------
5064 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
5067 // +-------+ +---------+ +---------+
5068 // | xapp | | submgr | | e2term |
5069 // +-------+ +---------+ +---------+
5072 // |---------------->| |
5074 // | RESTSubResp | |
5075 // |<----------------| |
5077 // | |------------->|
5080 // | |<-------------|
5083 // |<----------------| |
5086 // | Submgr restart |
5088 // | RESTSubDelReq | |
5089 // |---------------->| |
5092 // | |------------->|
5095 // | |<-------------|
5097 // | RESTSubDelResp | |
5098 // |<----------------| |
5100 //-----------------------------------------------------------------------------
5102 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
5103 CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle")
5105 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5106 Counter{cRestSubReqFromXapp, 1},
5107 Counter{cRestSubRespToXapp, 1},
5108 Counter{cSubReqToE2, 1},
5109 Counter{cSubRespFromE2, 1},
5110 Counter{cRestSubNotifToXapp, 1},
5111 Counter{cRestSubDelReqFromXapp, 1},
5112 Counter{cSubDelReqToE2, 1},
5113 Counter{cSubDelRespFromE2, 1},
5114 Counter{cRestSubDelRespToXapp, 1},
5116 // Remove possible existing subscription
5117 mainCtrl.removeExistingSubscriptions(t)
5119 var params *teststube2ap.RESTSubsReqParams = nil
5121 // Create subscription
5122 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5123 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5125 // Check subscription
5126 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5128 mainCtrl.SimulateRestart(t)
5129 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5131 // Check subscription
5132 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5134 // Delete subscription
5135 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
5137 //Wait that subs is cleaned
5138 waitSubsCleanup(t, e2SubsId, 10)
5140 mainCtrl.VerifyCounterValues(t)
5141 //mainCtrl.VerifyAllClean(t)
5144 //-----------------------------------------------------------------------------
5145 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
5148 // +-------+ +-------+ +---------+ +---------+
5149 // | xapp2 | | xapp1 | | submgr | | e2term |
5150 // +-------+ +-------+ +---------+ +---------+
5152 // | | RESTSubReq1 | |
5153 // | |---------------->| |
5155 // | | RESTSubResp1 | |
5156 // | |<----------------| |
5159 // | | |------------->|
5161 // | | |<-------------|
5162 // | | RESTNotif1 | |
5163 // | |<----------------| |
5165 // | RESTSubReq2 | |
5166 // |------------------------------>| |
5168 // | RESTSubResp2 | |
5169 // |<------------------------------| |
5171 // | | RESTNotif2 | |
5172 // |<------------------------------| |
5174 // | | Submgr restart |
5176 // | | RESTSubDelReq1 | |
5177 // | |---------------->| |
5179 // | | RESTSubDelResp1 | |
5180 // | |<----------------| |
5182 // | | Submgr restart |
5184 // | RESTSubDelReq2 | |
5185 // |------------------------------>| |
5187 // | RESTSubDelResp2 | |
5188 // |<------------------------------| |
5190 // | | | SubDelReq2 |
5191 // | | |------------->|
5193 // | | | SubDelResp2 |
5194 // | | |<-------------|
5197 //-----------------------------------------------------------------------------
5199 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
5200 CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
5202 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5203 Counter{cRestSubReqFromXapp, 2},
5204 Counter{cRestSubRespToXapp, 2},
5205 Counter{cSubReqToE2, 1},
5206 Counter{cSubRespFromE2, 1},
5207 Counter{cRestSubNotifToXapp, 2},
5208 Counter{cMergedSubscriptions, 1},
5209 Counter{cUnmergedSubscriptions, 1},
5210 Counter{cRestSubDelReqFromXapp, 2},
5211 Counter{cSubDelReqToE2, 1},
5212 Counter{cSubDelRespFromE2, 1},
5213 Counter{cRestSubDelRespToXapp, 2},
5216 // Remove possible existing subscription
5217 mainCtrl.removeExistingSubscriptions(t)
5219 var params *teststube2ap.RESTSubsReqParams = nil
5221 // Create subscription 1
5222 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5223 xapp.Logger.Debug("Send REST subscriber request for subscriber 1 : %v", restSubId1)
5225 // Create subscription 2 with same action
5226 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5227 params.SetMeid("RAN_NAME_1")
5228 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
5229 xappConn2.ExpectAnyNotification(t)
5230 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5231 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5232 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
5233 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
5235 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
5237 mainCtrl.SimulateRestart(t)
5238 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5240 // Delete subscription 1, and wait until it has removed the first endpoint
5241 subepcnt := mainCtrl.get_subs_entrypoint_cnt(t, e2SubsId1)
5242 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5243 mainCtrl.wait_subs_entrypoint_cnt_change(t, e2SubsId1, subepcnt, 10)
5245 mainCtrl.SimulateRestart(t)
5246 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5247 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
5249 // Delete subscription 2
5250 deleteXapp2Subscription(t, &restSubId2)
5252 //Wait that subs is cleaned
5253 waitSubsCleanup(t, e2SubsId2, 10)
5255 mainCtrl.VerifyCounterValues(t)
5256 //mainCtrl.VerifyAllClean(t)
5259 //-----------------------------------------------------------------------------
5260 // TestRESTReportSubReqAndSubDelOk
5263 // +-------+ +---------+ +---------+
5264 // | xapp | | submgr | | e2term |
5265 // +-------+ +---------+ +---------+
5268 // |---------------->| |
5270 // | RESTSubResp | |
5271 // |<----------------| |
5274 // | |------------->|
5277 // | |<-------------|
5279 // |<----------------| |
5281 // | |------------->|
5284 // | |<-------------|
5286 // |<----------------| |
5290 // | RESTSubDelReq | |
5291 // |---------------->| |
5294 // | |------------->|
5297 // | |<-------------|
5299 // | RESTSubDelResp| |
5300 // |<----------------| |
5302 //-----------------------------------------------------------------------------
5304 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
5305 CaseBegin("TestRESTReportSubReqAndSubDelOk")
5306 const subReqCount int = 1
5308 RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
5311 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5312 xapp.Logger.Debug("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
5315 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5316 restSubId := xappConn1.SendRESTSubsReq(t, params)
5318 var e2SubsId []uint32
5319 for i := 0; i < subReqCount; i++ {
5320 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5321 xappConn1.ExpectRESTNotification(t, restSubId)
5323 e2termConn1.SendSubsResp(t, crereq, cremsg)
5324 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5325 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5326 e2SubsId = append(e2SubsId, instanceId)
5327 resp, _ := xapp.Subscription.QuerySubscriptions()
5328 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
5329 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
5330 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
5335 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5337 for i := 0; i < subReqCount; i++ {
5338 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5339 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5342 // Wait that subs is cleaned
5343 for i := 0; i < subReqCount; i++ {
5344 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5347 xappConn1.TestMsgChanEmpty(t)
5348 e2termConn1.TestMsgChanEmpty(t)
5349 mainCtrl.wait_registry_empty(t, 10)
5350 //mainCtrl.VerifyAllClean(t)
5354 func TestRESTPolicySubReqAndSubDelOk(t *testing.T) {
5355 CaseBegin("TestRESTPolicySubReqAndSubDelOk")
5359 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5363 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5366 func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5367 xapp.Logger.Debug("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
5370 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5371 restSubId := xappConn1.SendRESTSubsReq(t, params)
5373 var e2SubsId []uint32
5374 for i := 0; i < subReqCount; i++ {
5375 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5376 xappConn1.ExpectRESTNotification(t, restSubId)
5377 e2termConn1.SendSubsResp(t, crereq, cremsg)
5378 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5379 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5380 e2SubsId = append(e2SubsId, instanceId)
5384 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5386 for i := 0; i < subReqCount; i++ {
5387 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5388 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5391 // Wait that subs is cleaned
5392 for i := 0; i < subReqCount; i++ {
5393 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5395 xappConn1.TestMsgChanEmpty(t)
5396 e2termConn1.TestMsgChanEmpty(t)
5397 mainCtrl.wait_registry_empty(t, 10)
5398 //mainCtrl.VerifyAllClean(t)
5401 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
5403 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5404 Counter{cRestSubReqFromXapp, 1},
5405 Counter{cRestSubRespToXapp, 1},
5406 Counter{cSubReqToE2, 2},
5407 Counter{cSubRespFromE2, 2},
5408 Counter{cRestSubNotifToXapp, 2},
5409 Counter{cRestSubDelReqFromXapp, 1},
5410 Counter{cSubDelReqToE2, 2},
5411 Counter{cSubDelRespFromE2, 2},
5412 Counter{cRestSubDelRespToXapp, 1},
5415 const subReqCount int = 2
5418 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5419 restSubId := xappConn1.SendRESTSubsReq(t, params)
5420 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5422 assert.Equal(t, len(e2SubsIds), 2)
5425 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5426 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5428 xappConn1.TestMsgChanEmpty(t)
5429 e2termConn1.TestMsgChanEmpty(t)
5430 mainCtrl.wait_registry_empty(t, 10)
5432 mainCtrl.VerifyCounterValues(t)
5433 //mainCtrl.VerifyAllClean(t)
5435 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
5437 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5438 Counter{cRestSubReqFromXapp, 1},
5439 Counter{cRestSubRespToXapp, 1},
5440 Counter{cSubReqToE2, 19},
5441 Counter{cSubRespFromE2, 19},
5442 Counter{cRestSubNotifToXapp, 19},
5443 Counter{cRestSubDelReqFromXapp, 1},
5444 Counter{cSubDelReqToE2, 19},
5445 Counter{cSubDelRespFromE2, 19},
5446 Counter{cRestSubDelRespToXapp, 1},
5449 const subReqCount int = 19
5451 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5452 restSubId := xappConn1.SendRESTSubsReq(t, params)
5453 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5455 assert.Equal(t, len(e2SubsIds), 19)
5457 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5458 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5460 xappConn1.TestMsgChanEmpty(t)
5461 e2termConn1.TestMsgChanEmpty(t)
5462 mainCtrl.wait_registry_empty(t, 10)
5464 mainCtrl.VerifyCounterValues(t)
5465 //mainCtrl.VerifyAllClean(t)
5468 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
5472 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5473 Counter{cRestSubReqFromXapp, 1},
5474 Counter{cRestSubRespToXapp, 1},
5475 Counter{cSubReqToE2, uint64(subReqCount)},
5476 Counter{cSubRespFromE2, uint64(subReqCount)},
5477 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5478 Counter{cRestSubDelReqFromXapp, 1},
5479 Counter{cSubDelReqToE2, uint64(subReqCount)},
5480 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5481 Counter{cRestSubDelRespToXapp, 1},
5485 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5486 restSubId := xappConn1.SendRESTSubsReq(t, params)
5487 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5489 assert.Equal(t, len(e2SubsIds), subReqCount)
5492 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5493 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5495 xappConn1.TestMsgChanEmpty(t)
5496 e2termConn1.TestMsgChanEmpty(t)
5497 mainCtrl.wait_registry_empty(t, 10)
5499 mainCtrl.VerifyCounterValues(t)
5500 //mainCtrl.VerifyAllClean(t)
5503 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
5507 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5508 Counter{cRestSubReqFromXapp, 1},
5509 Counter{cRestSubRespToXapp, 1},
5510 Counter{cSubReqToE2, uint64(subReqCount)},
5511 Counter{cSubRespFromE2, uint64(subReqCount)},
5512 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5513 Counter{cRestSubDelReqFromXapp, 1},
5514 Counter{cSubDelReqToE2, uint64(subReqCount)},
5515 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5516 Counter{cRestSubDelRespToXapp, 1},
5520 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5521 restSubId := xappConn1.SendRESTSubsReq(t, params)
5522 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5524 assert.Equal(t, len(e2SubsIds), subReqCount)
5527 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5528 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5530 xappConn1.TestMsgChanEmpty(t)
5531 e2termConn1.TestMsgChanEmpty(t)
5532 mainCtrl.wait_registry_empty(t, 10)
5534 mainCtrl.VerifyCounterValues(t)
5535 //mainCtrl.VerifyAllClean(t)
5538 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
5542 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5543 Counter{cRestSubReqFromXapp, 1},
5544 Counter{cRestSubRespToXapp, 1},
5545 Counter{cSubReqToE2, uint64(subReqCount)},
5546 Counter{cSubRespFromE2, uint64(subReqCount)},
5547 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5548 Counter{cRestSubDelReqFromXapp, 1},
5549 Counter{cSubDelReqToE2, uint64(subReqCount)},
5550 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5551 Counter{cRestSubDelRespToXapp, 1},
5555 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5556 restSubId := xappConn1.SendRESTSubsReq(t, params)
5557 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5559 assert.Equal(t, len(e2SubsIds), subReqCount)
5562 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5563 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5565 xappConn1.TestMsgChanEmpty(t)
5566 e2termConn1.TestMsgChanEmpty(t)
5567 mainCtrl.wait_registry_empty(t, 10)
5569 mainCtrl.VerifyCounterValues(t)
5570 //mainCtrl.VerifyAllClean(t)
5573 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
5574 CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
5576 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5577 Counter{cRestSubReqFromXapp, 2},
5578 Counter{cRestSubRespToXapp, 2},
5579 Counter{cSubReqToE2, 2},
5580 Counter{cSubRespFromE2, 2},
5581 Counter{cRestSubNotifToXapp, 2},
5582 Counter{cRestSubDelReqFromXapp, 2},
5583 Counter{cSubDelReqToE2, 2},
5584 Counter{cSubDelRespFromE2, 2},
5585 Counter{cRestSubDelRespToXapp, 2},
5589 var params *teststube2ap.RESTSubsReqParams = nil
5592 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5593 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5595 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5598 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5599 params.SetMeid("RAN_NAME_1")
5600 eventTriggerDefinition := []int64{1234, 1}
5601 params.SetSubEventTriggerDefinition(eventTriggerDefinition)
5603 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5604 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5605 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5606 xappConn2.ExpectRESTNotification(t, restSubId2)
5607 e2termConn1.SendSubsResp(t, crereq, cremsg)
5608 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5610 deleteXapp1Subscription(t, &restSubId1)
5611 deleteXapp2Subscription(t, &restSubId2)
5613 waitSubsCleanup(t, e2SubsId1, 10)
5614 waitSubsCleanup(t, e2SubsId2, 10)
5616 mainCtrl.VerifyCounterValues(t)
5617 //mainCtrl.VerifyAllClean(t)
5620 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
5621 CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
5623 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5624 Counter{cRestSubReqFromXapp, 2},
5625 Counter{cRestSubRespToXapp, 2},
5626 Counter{cSubReqToE2, 2},
5627 Counter{cSubRespFromE2, 2},
5628 Counter{cRestSubNotifToXapp, 2},
5629 Counter{cRestSubDelReqFromXapp, 2},
5630 Counter{cSubDelReqToE2, 2},
5631 Counter{cSubDelRespFromE2, 2},
5632 Counter{cRestSubDelRespToXapp, 2},
5636 var params *teststube2ap.RESTSubsReqParams = nil
5639 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5640 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5642 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5645 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5646 params.SetMeid("RAN_NAME_1")
5648 actionId := int64(1)
5649 actionType := "report"
5650 actionDefinition := []int64{5678, 1}
5651 subsequestActionType := "continue"
5652 timeToWait := "w10ms"
5653 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
5655 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5656 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5657 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5658 xappConn2.ExpectRESTNotification(t, restSubId2)
5659 e2termConn1.SendSubsResp(t, crereq, cremsg)
5660 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5662 deleteXapp1Subscription(t, &restSubId1)
5663 deleteXapp2Subscription(t, &restSubId2)
5665 waitSubsCleanup(t, e2SubsId1, 10)
5666 waitSubsCleanup(t, e2SubsId2, 10)
5668 mainCtrl.VerifyCounterValues(t)
5669 //mainCtrl.VerifyAllClean(t)
5672 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
5673 CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
5675 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5676 Counter{cRestSubReqFromXapp, 2},
5677 Counter{cRestSubRespToXapp, 2},
5678 Counter{cSubReqToE2, 2},
5679 Counter{cSubRespFromE2, 2},
5680 Counter{cRestSubNotifToXapp, 2},
5681 Counter{cRestSubDelReqFromXapp, 2},
5682 Counter{cSubDelReqToE2, 2},
5683 Counter{cSubDelRespFromE2, 2},
5684 Counter{cRestSubDelRespToXapp, 2},
5688 var params *teststube2ap.RESTSubsReqParams = nil
5691 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5692 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5694 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5697 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5698 params.SetMeid("RAN_NAME_1")
5699 params.SetSubActionIDs(int64(2))
5701 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5702 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5703 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5704 xappConn2.ExpectRESTNotification(t, restSubId2)
5705 e2termConn1.SendSubsResp(t, crereq, cremsg)
5706 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5708 deleteXapp1Subscription(t, &restSubId1)
5709 deleteXapp2Subscription(t, &restSubId2)
5711 waitSubsCleanup(t, e2SubsId1, 10)
5712 waitSubsCleanup(t, e2SubsId2, 10)
5714 mainCtrl.VerifyCounterValues(t)
5715 //mainCtrl.VerifyAllClean(t)
5718 func TestRESTSubReqDiffActionType(t *testing.T) {
5719 CaseBegin("TestRESTSubReqDiffActionType")
5721 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5722 Counter{cRestSubReqFromXapp, 2},
5723 Counter{cRestSubRespToXapp, 2},
5724 Counter{cSubReqToE2, 2},
5725 Counter{cSubRespFromE2, 2},
5726 Counter{cRestSubNotifToXapp, 2},
5727 Counter{cRestSubDelReqFromXapp, 2},
5728 Counter{cSubDelReqToE2, 2},
5729 Counter{cSubDelRespFromE2, 2},
5730 Counter{cRestSubDelRespToXapp, 2},
5733 const e2Timeout int64 = 2
5734 const e2RetryCount int64 = 2
5735 const routingNeeded bool = true
5738 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5739 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5742 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5743 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5745 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5748 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5749 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5750 params.SetMeid("RAN_NAME_1")
5752 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5753 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5754 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5755 xappConn2.ExpectRESTNotification(t, restSubId2)
5756 e2termConn1.SendSubsResp(t, crereq, cremsg)
5757 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5759 deleteXapp1Subscription(t, &restSubId1)
5760 deleteXapp2Subscription(t, &restSubId2)
5762 waitSubsCleanup(t, e2SubsId1, 10)
5763 waitSubsCleanup(t, e2SubsId2, 10)
5765 mainCtrl.VerifyCounterValues(t)
5766 //mainCtrl.VerifyAllClean(t)
5769 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
5770 CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
5772 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5773 Counter{cRestSubReqFromXapp, 2},
5774 Counter{cRestSubRespToXapp, 2},
5775 Counter{cSubReqToE2, 2},
5776 Counter{cSubRespFromE2, 2},
5777 Counter{cRestSubNotifToXapp, 2},
5778 Counter{cRestSubDelReqFromXapp, 2},
5779 Counter{cSubDelReqToE2, 2},
5780 Counter{cSubDelRespFromE2, 2},
5781 Counter{cRestSubDelRespToXapp, 2},
5784 const e2Timeout int64 = 2
5785 const e2RetryCount int64 = 2
5786 const routingNeeded bool = true
5789 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5790 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5793 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5794 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5796 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5799 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
5800 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5801 params.SetMeid("RAN_NAME_1")
5803 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5804 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5805 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5806 xappConn2.ExpectRESTNotification(t, restSubId2)
5807 e2termConn1.SendSubsResp(t, crereq, cremsg)
5808 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5810 deleteXapp1Subscription(t, &restSubId1)
5811 deleteXapp2Subscription(t, &restSubId2)
5813 waitSubsCleanup(t, e2SubsId1, 10)
5814 waitSubsCleanup(t, e2SubsId2, 10)
5816 mainCtrl.VerifyCounterValues(t)
5817 //mainCtrl.VerifyAllClean(t)
5820 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
5821 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
5823 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5824 Counter{cRestSubReqFromXapp, 2},
5825 Counter{cRestSubRespToXapp, 2},
5826 Counter{cSubReqToE2, 2},
5827 Counter{cSubRespFromE2, 2},
5828 Counter{cRestSubNotifToXapp, 2},
5829 Counter{cRestSubDelReqFromXapp, 2},
5830 Counter{cSubDelReqToE2, 2},
5831 Counter{cSubDelRespFromE2, 2},
5832 Counter{cRestSubDelRespToXapp, 2},
5836 var params *teststube2ap.RESTSubsReqParams = nil
5839 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5840 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5842 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5845 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5846 params.SetMeid("RAN_NAME_1")
5847 actionDefinition := []int64{5678, 1}
5848 params.SetSubActionDefinition(actionDefinition)
5850 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5851 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5852 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5853 xappConn2.ExpectRESTNotification(t, restSubId2)
5854 e2termConn1.SendSubsResp(t, crereq, cremsg)
5855 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5857 deleteXapp1Subscription(t, &restSubId1)
5858 deleteXapp2Subscription(t, &restSubId2)
5860 waitSubsCleanup(t, e2SubsId1, 10)
5861 waitSubsCleanup(t, e2SubsId2, 10)
5863 mainCtrl.VerifyCounterValues(t)
5864 //mainCtrl.VerifyAllClean(t)
5867 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
5868 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
5870 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5871 Counter{cRestSubReqFromXapp, 2},
5872 Counter{cRestSubRespToXapp, 2},
5873 Counter{cSubReqToE2, 2},
5874 Counter{cSubRespFromE2, 2},
5875 Counter{cRestSubNotifToXapp, 2},
5876 Counter{cRestSubDelReqFromXapp, 2},
5877 Counter{cSubDelReqToE2, 2},
5878 Counter{cSubDelRespFromE2, 2},
5879 Counter{cRestSubDelRespToXapp, 2},
5883 var params *teststube2ap.RESTSubsReqParams = nil
5886 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5887 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5889 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5892 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5893 params.SetMeid("RAN_NAME_1")
5894 actionDefinition := []int64{56782}
5895 params.SetSubActionDefinition(actionDefinition)
5897 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5898 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5899 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5900 xappConn2.ExpectRESTNotification(t, restSubId2)
5901 e2termConn1.SendSubsResp(t, crereq, cremsg)
5902 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5904 deleteXapp1Subscription(t, &restSubId1)
5905 deleteXapp2Subscription(t, &restSubId2)
5907 waitSubsCleanup(t, e2SubsId1, 10)
5908 waitSubsCleanup(t, e2SubsId2, 10)
5910 mainCtrl.VerifyCounterValues(t)
5911 //mainCtrl.VerifyAllClean(t)
5914 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
5915 CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
5917 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5918 Counter{cRestSubReqFromXapp, 2},
5919 Counter{cRestSubRespToXapp, 2},
5920 Counter{cSubReqToE2, 2},
5921 Counter{cSubRespFromE2, 2},
5922 Counter{cRestSubNotifToXapp, 2},
5923 Counter{cRestSubDelReqFromXapp, 2},
5924 Counter{cSubDelReqToE2, 2},
5925 Counter{cSubDelRespFromE2, 2},
5926 Counter{cRestSubDelRespToXapp, 2},
5930 var params *teststube2ap.RESTSubsReqParams = nil
5933 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5934 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5936 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5939 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5940 params.SetMeid("RAN_NAME_1")
5941 params.SetTimeToWait("w200ms")
5942 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5943 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5944 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5945 xappConn2.ExpectRESTNotification(t, restSubId2)
5946 e2termConn1.SendSubsResp(t, crereq, cremsg)
5947 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5949 deleteXapp1Subscription(t, &restSubId1)
5950 deleteXapp2Subscription(t, &restSubId2)
5952 waitSubsCleanup(t, e2SubsId1, 10)
5953 waitSubsCleanup(t, e2SubsId2, 10)
5955 mainCtrl.VerifyCounterValues(t)
5956 //mainCtrl.VerifyAllClean(t)
5959 //-----------------------------------------------------------------------------
5960 // TestRESTUnpackSubscriptionResponseDecodeFail
5963 // +-------+ +---------+ +---------+
5964 // | xapp | | submgr | | e2term |
5965 // +-------+ +---------+ +---------+
5968 // |---------------->| |
5970 // | RESTSubResp | |
5971 // |<----------------| |
5974 // | |------------->|
5976 // | | SubResp | ASN.1 decode fails
5977 // | |<-------------|
5980 // | |------------->|
5982 // | | SubFail | Duplicated action
5983 // | |<-------------|
5984 // | RESTNotif (fail)| |
5985 // |<----------------| |
5988 //-----------------------------------------------------------------------------
5990 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
5991 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
5992 const subReqCount int = 1
5995 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5996 restSubId := xappConn1.SendRESTSubsReq(t, params)
5998 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5999 // Decode of this response fails which will result resending original request
6000 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
6002 _, cremsg = e2termConn1.RecvSubsReq(t)
6004 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6006 // Subscription already created in E2 Node.
6007 fparams := &teststube2ap.E2StubSubsFailParams{}
6009 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6010 e2termConn1.SendSubsFail(t, fparams, cremsg)
6012 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6013 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6015 // Wait that subs is cleaned
6016 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6018 xappConn1.TestMsgChanEmpty(t)
6019 e2termConn1.TestMsgChanEmpty(t)
6020 mainCtrl.wait_registry_empty(t, 10)
6021 //mainCtrl.VerifyAllClean(t)
6024 //-----------------------------------------------------------------------------
6025 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
6028 // +-------+ +---------+ +---------+
6029 // | xapp | | submgr | | e2term |
6030 // +-------+ +---------+ +---------+
6033 // |---------------->| |
6035 // | RESTSubResp | |
6036 // |<----------------| |
6039 // | |------------->|
6041 // | | SubResp | Unknown instanceId
6042 // | |<-------------|
6045 // | |------------->|
6047 // | | SubFail | Duplicated action
6048 // | |<-------------|
6049 // | RESTNotif (fail)| |
6050 // |<----------------| |
6052 // | |------------->|
6055 // | |<-------------|
6057 //-----------------------------------------------------------------------------
6059 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
6060 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
6061 const subReqCount int = 1
6064 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6065 restSubId := xappConn1.SendRESTSubsReq(t, params)
6067 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6069 // Unknown instanceId in this response which will result resending original request
6070 orgInstanceId := crereq.RequestId.InstanceId
6071 crereq.RequestId.InstanceId = 0
6072 e2termConn1.SendSubsResp(t, crereq, cremsg)
6074 _, cremsg = e2termConn1.RecvSubsReq(t)
6076 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6078 // Subscription already created in E2 Node.
6079 fparams := &teststube2ap.E2StubSubsFailParams{}
6081 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6082 e2termConn1.SendSubsFail(t, fparams, cremsg)
6084 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6085 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6087 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6088 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6090 // Wait that subs is cleaned
6091 mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
6093 xappConn1.TestMsgChanEmpty(t)
6094 e2termConn1.TestMsgChanEmpty(t)
6095 mainCtrl.wait_registry_empty(t, 10)
6096 //mainCtrl.VerifyAllClean(t)
6099 //-----------------------------------------------------------------------------
6100 // TestRESTUnpackSubscriptionResponseNoTransaction
6103 // +-------+ +---------+ +---------+
6104 // | xapp | | submgr | | e2term |
6105 // +-------+ +---------+ +---------+
6108 // |---------------->| |
6110 // | RESTSubResp | |
6111 // |<----------------| |
6114 // | |------------->|
6116 // | | SubResp | No transaction for the response
6117 // | |<-------------|
6120 // | |------------->|
6122 // | | SubFail | Duplicated action
6123 // | |<-------------|
6124 // | RESTNotif (fail)| |
6125 // |<----------------| |
6127 // | |------------->|
6130 // | |<-------------|
6133 // | |------------->|
6136 // | |<-------------|
6138 //-----------------------------------------------------------------------------
6139 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
6140 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
6141 const subReqCount int = 1
6144 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6145 restSubId := xappConn1.SendRESTSubsReq(t, params)
6147 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6149 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6150 // No transaction exist for this response which will result resending original request
6151 e2termConn1.SendSubsResp(t, crereq, cremsg)
6153 _, cremsg = e2termConn1.RecvSubsReq(t)
6155 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6157 // Subscription already created in E2 Node.
6158 fparams := &teststube2ap.E2StubSubsFailParams{}
6160 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6161 e2termConn1.SendSubsFail(t, fparams, cremsg)
6163 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6164 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6166 // Resending happens because there no transaction
6167 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6168 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6170 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6171 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6173 // Wait that subs is cleaned
6174 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6176 xappConn1.TestMsgChanEmpty(t)
6177 e2termConn1.TestMsgChanEmpty(t)
6178 mainCtrl.wait_registry_empty(t, 10)
6179 //mainCtrl.VerifyAllClean(t)
6182 //-----------------------------------------------------------------------------
6183 // TestRESTUnpackSubscriptionFailureDecodeFail
6186 // +-------+ +---------+ +---------+
6187 // | xapp | | submgr | | e2term |
6188 // +-------+ +---------+ +---------+
6191 // |---------------->| |
6193 // | RESTSubResp | |
6194 // |<----------------| |
6197 // | |------------->|
6199 // | | SubFail | ASN.1 decode fails
6200 // | |<-------------|
6203 // | |------------->|
6205 // | | SubFail | Duplicated action
6206 // | |<-------------|
6207 // | RESTNotif (fail)| |
6208 // |<----------------| |
6211 //-----------------------------------------------------------------------------
6212 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
6213 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
6214 const subReqCount int = 1
6217 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6218 restSubId := xappConn1.SendRESTSubsReq(t, params)
6220 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6222 // Decode of this response fails which will result resending original request
6223 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
6225 _, cremsg = e2termConn1.RecvSubsReq(t)
6227 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6229 // Subscription already created in E2 Node.
6230 fparams := &teststube2ap.E2StubSubsFailParams{}
6232 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6233 e2termConn1.SendSubsFail(t, fparams, cremsg)
6235 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6236 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6238 // Wait that subs is cleaned
6239 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6241 xappConn1.TestMsgChanEmpty(t)
6242 e2termConn1.TestMsgChanEmpty(t)
6243 mainCtrl.wait_registry_empty(t, 10)
6244 //mainCtrl.VerifyAllClean(t)
6247 //-----------------------------------------------------------------------------
6248 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
6251 // +-------+ +---------+ +---------+
6252 // | xapp | | submgr | | e2term |
6253 // +-------+ +---------+ +---------+
6256 // |---------------->| |
6258 // | RESTSubResp | |
6259 // |<----------------| |
6262 // | |------------->|
6264 // | | SubFail | Unknown instanceId
6265 // | |<-------------|
6268 // | |------------->|
6270 // | | SubFail | Duplicated action
6271 // | |<-------------|
6272 // | RESTNotif (fail)| |
6273 // |<----------------| |
6275 // | |------------->|
6278 // | |<-------------|
6280 //-----------------------------------------------------------------------------
6281 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
6282 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
6283 const subReqCount int = 1
6286 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6287 restSubId := xappConn1.SendRESTSubsReq(t, params)
6289 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6291 // Unknown instanceId in this response which will result resending original request
6292 fparams := &teststube2ap.E2StubSubsFailParams{}
6294 fparams.Fail.RequestId.InstanceId = 0
6295 e2termConn1.SendSubsFail(t, fparams, cremsg)
6297 _, cremsg = e2termConn1.RecvSubsReq(t)
6299 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6301 // Subscription already created in E2 Node.
6302 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6303 e2termConn1.SendSubsFail(t, fparams, cremsg)
6305 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6306 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6308 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6309 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6311 // Wait that subs is cleaned
6312 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6314 xappConn1.TestMsgChanEmpty(t)
6315 e2termConn1.TestMsgChanEmpty(t)
6316 mainCtrl.wait_registry_empty(t, 10)
6317 //mainCtrl.VerifyAllClean(t)
6320 //-----------------------------------------------------------------------------
6321 // TestRESTUnpackSubscriptionFailureNoTransaction
6324 // +-------+ +---------+ +---------+
6325 // | xapp | | submgr | | e2term |
6326 // +-------+ +---------+ +---------+
6329 // |---------------->| |
6331 // | RESTSubResp | |
6332 // |<----------------| |
6335 // | |------------->|
6337 // | | SubFail | No transaction for the response
6338 // | |<-------------|
6341 // | |------------->|
6343 // | | SubFail | Duplicated action
6344 // | |<-------------|
6345 // | RESTNotif (fail)| |
6346 // |<----------------| |
6348 // | |------------->|
6351 // | |<-------------|
6353 //-----------------------------------------------------------------------------
6354 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
6355 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
6356 const subReqCount int = 1
6359 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6360 restSubId := xappConn1.SendRESTSubsReq(t, params)
6362 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6364 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6366 // No transaction exist for this response which will result resending original request
6367 fparams := &teststube2ap.E2StubSubsFailParams{}
6369 e2termConn1.SendSubsFail(t, fparams, cremsg)
6371 _, cremsg = e2termConn1.RecvSubsReq(t)
6373 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6375 // Subscription already created in E2 Node.
6376 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6377 e2termConn1.SendSubsFail(t, fparams, cremsg)
6379 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6380 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6382 // Resending happens because there no transaction
6383 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6384 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6386 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6387 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6389 // Wait that subs is cleaned
6390 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6392 xappConn1.TestMsgChanEmpty(t)
6393 e2termConn1.TestMsgChanEmpty(t)
6394 mainCtrl.wait_registry_empty(t, 10)
6395 //mainCtrl.VerifyAllClean(t)
6398 //-----------------------------------------------------------------------------
6399 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
6402 // +-------+ +---------+ +---------+
6403 // | xapp | | submgr | | e2term |
6404 // +-------+ +---------+ +---------+
6406 // | [SUBS CREATE] |
6409 // | RESTSubDelReq | |
6410 // |---------------->| |
6412 // | RESTSubDelResp | |
6413 // |<----------------| |
6416 // | |------------->|
6418 // | | SubDelResp | ASN.1 decode fails
6419 // | |<-------------|
6422 // | |------------->|
6424 // | | SubDelFail | Subscription does exist any more
6425 // | |<-------------|
6428 //-----------------------------------------------------------------------------
6429 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
6430 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail")
6433 var params *teststube2ap.RESTSubsReqParams = nil
6434 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6437 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6439 // E2t: Receive 1st SubsDelReq
6440 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6442 // Decode of this response fails which will result resending original request
6443 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_REQ)
6445 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6446 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6448 // Subscription does not exist in in E2 Node.
6449 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6451 // Wait that subs is cleaned
6452 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6454 xappConn1.TestMsgChanEmpty(t)
6455 e2termConn1.TestMsgChanEmpty(t)
6456 mainCtrl.wait_registry_empty(t, 10)
6457 //mainCtrl.VerifyAllClean(t)
6460 //-----------------------------------------------------------------------------
6461 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
6464 // +-------+ +---------+ +---------+
6465 // | xapp | | submgr | | e2term |
6466 // +-------+ +---------+ +---------+
6468 // | [SUBS CREATE] |
6471 // | RESTSubDelReq | |
6472 // |---------------->| |
6474 // | RESTSubDelResp | |
6475 // |<----------------| |
6478 // | |------------->|
6480 // | | SubDelResp | Unknown instanceId
6481 // | |<-------------|
6484 // | |------------->|
6486 // | | SubDelFail | Subscription does exist any more
6487 // | |<-------------|
6489 //-----------------------------------------------------------------------------
6490 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
6491 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId")
6494 var params *teststube2ap.RESTSubsReqParams = nil
6495 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6498 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6500 // E2t: Receive 1st SubsDelReq
6501 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6503 // Unknown instanceId in this response which will result resending original request
6504 delreq.RequestId.InstanceId = 0
6505 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6507 // E2t: Receive 2nd SubsDelReq
6508 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6510 // Subscription does not exist in in E2 Node.
6511 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6513 // Wait that subs is cleaned
6514 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6516 xappConn1.TestMsgChanEmpty(t)
6517 e2termConn1.TestMsgChanEmpty(t)
6518 mainCtrl.wait_registry_empty(t, 10)
6519 //mainCtrl.VerifyAllClean(t)
6522 //-----------------------------------------------------------------------------
6523 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
6526 // +-------+ +---------+ +---------+
6527 // | xapp | | submgr | | e2term |
6528 // +-------+ +---------+ +---------+
6530 // | [SUBS CREATE] |
6533 // | RESTSubDelReq | |
6534 // |---------------->| |
6536 // | RESTSubDelResp | |
6537 // |<----------------| |
6540 // | |------------->|
6542 // | | SubDelResp | No transaction for the response
6543 // | |<-------------|
6546 // | |------------->|
6548 // | | SubDelFail | Subscription does exist any more
6549 // | |<-------------|
6551 //-----------------------------------------------------------------------------
6552 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
6553 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction")
6556 var params *teststube2ap.RESTSubsReqParams = nil
6557 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6560 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6562 // E2t: Receive 1st SubsDelReq
6563 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6565 mainCtrl.MakeTransactionNil(t, e2SubsId)
6567 // No transaction exist for this response which will result resending original request
6568 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6570 // E2t: Receive 2nd SubsDelReq
6571 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6573 // Subscription does not exist in in E2 Node.
6574 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6576 // Wait that subs is cleaned
6577 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6579 xappConn1.TestMsgChanEmpty(t)
6580 e2termConn1.TestMsgChanEmpty(t)
6581 mainCtrl.wait_registry_empty(t, 10)
6582 //mainCtrl.VerifyAllClean(t)
6585 //-----------------------------------------------------------------------------
6586 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
6589 // +-------+ +---------+ +---------+
6590 // | xapp | | submgr | | e2term |
6591 // +-------+ +---------+ +---------+
6593 // | [SUBS CREATE] |
6596 // | RESTSubDelReq | |
6597 // |---------------->| |
6599 // | RESTSubDelResp | |
6600 // |<----------------| |
6603 // | |------------->|
6605 // | | SubDelFail | ASN.1 decode fails
6606 // | |<-------------|
6609 // | |------------->|
6611 // | | SubDelFail | Subscription does exist any more
6612 // | |<-------------|
6614 //-----------------------------------------------------------------------------
6615 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
6616 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail")
6619 var params *teststube2ap.RESTSubsReqParams = nil
6620 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6623 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6625 // E2t: Receive 1st SubsDelReq
6626 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6628 // Decode of this response fails which will result resending original request
6629 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
6631 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6632 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6634 // Subscription does not exist in in E2 Node.
6635 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6637 // Wait that subs is cleaned
6638 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6640 xappConn1.TestMsgChanEmpty(t)
6641 e2termConn1.TestMsgChanEmpty(t)
6642 mainCtrl.wait_registry_empty(t, 10)
6643 //mainCtrl.VerifyAllClean(t)
6646 //-----------------------------------------------------------------------------
6647 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
6650 // +-------+ +---------+ +---------+
6651 // | xapp | | submgr | | e2term |
6652 // +-------+ +---------+ +---------+
6654 // | [SUBS CREATE] |
6657 // | RESTSubDelReq | |
6658 // |---------------->| |
6660 // | RESTSubDelResp | |
6661 // |<----------------| |
6664 // | |------------->|
6666 // | | SubDelFail | Unknown instanceId
6667 // | |<-------------|
6670 // | |------------->|
6672 // | | SubDelFail | Subscription does exist any more
6673 // | |<-------------|
6675 //-----------------------------------------------------------------------------
6676 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
6677 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId")
6680 var params *teststube2ap.RESTSubsReqParams = nil
6681 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6684 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6686 // E2t: Receive 1st SubsDelReq
6687 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6689 // Unknown instanceId in this response which will result resending original request
6690 delreq.RequestId.InstanceId = 0
6691 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6693 // E2t: Receive 2nd SubsDelReq
6694 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6696 // Subscription does not exist in in E2 Node.
6697 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6699 // Wait that subs is cleaned
6700 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6702 xappConn1.TestMsgChanEmpty(t)
6703 e2termConn1.TestMsgChanEmpty(t)
6704 mainCtrl.wait_registry_empty(t, 10)
6705 //mainCtrl.VerifyAllClean(t)
6708 //-----------------------------------------------------------------------------
6709 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
6712 // +-------+ +---------+ +---------+
6713 // | xapp | | submgr | | e2term |
6714 // +-------+ +---------+ +---------+
6716 // | [SUBS CREATE] |
6719 // | RESTSubDelReq | |
6720 // |---------------->| |
6722 // | RESTSubDelResp | |
6723 // |<----------------| |
6726 // | |------------->|
6728 // | | SubDelFail | No transaction for the response
6729 // | |<-------------|
6732 // | |------------->|
6734 // | | SubDelFail | Subscription does exist any more
6735 // | |<-------------|
6737 //-----------------------------------------------------------------------------
6738 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
6739 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction")
6742 var params *teststube2ap.RESTSubsReqParams = nil
6743 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6746 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6748 // E2t: Receive 1st SubsDelReq
6749 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6751 mainCtrl.MakeTransactionNil(t, e2SubsId)
6753 // No transaction exist for this response which will result resending original request
6754 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6756 // E2t: Receive 2nd SubsDelReq
6757 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6759 // Subscription does not exist in in E2 Node.
6760 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6762 // Wait that subs is cleaned
6763 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6765 xappConn1.TestMsgChanEmpty(t)
6766 e2termConn1.TestMsgChanEmpty(t)
6767 mainCtrl.wait_registry_empty(t, 10)
6768 //mainCtrl.VerifyAllClean(t)
6771 //-----------------------------------------------------------------------------
6772 // TestRESTSubReqFailAsn1PackSubReqError
6775 // +-------+ +---------+ +---------+
6776 // | xapp | | submgr | | e2term |
6777 // +-------+ +---------+ +---------+
6780 // |---------------->| |
6782 // | RESTSubResp | |
6783 // |<----------------| |
6785 // | ASN.1 encode fails |
6788 // | |------------->|
6791 // | |<-------------|
6795 // |<----------------| |
6797 // | [SUBS DELETE] |
6800 //-----------------------------------------------------------------------------
6801 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
6803 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6804 Counter{cRestSubReqFromXapp, 1},
6805 Counter{cRestSubRespToXapp, 1},
6806 Counter{cRestSubFailNotifToXapp, 1},
6809 const subReqCount int = 1
6811 var params *teststube2ap.RESTSubsReqParams = nil
6812 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
6813 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
6816 restSubId := xappConn1.SendRESTSubsReq(t, params)
6817 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
6819 // E2t: Receive SubsDelReq
6820 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6822 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6823 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
6825 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
6826 // Wait that subs is cleaned
6827 waitSubsCleanup(t, e2SubsId, 10)
6828 mainCtrl.VerifyCounterValues(t)
6829 //mainCtrl.VerifyAllClean(t)
6832 func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
6833 CaseBegin("TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction")
6835 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6836 Counter{cRestSubReqFromXapp, 2},
6837 Counter{cRestSubRespToXapp, 2},
6838 Counter{cSubReqToE2, 2},
6839 Counter{cSubReqTimerExpiry, 1},
6840 Counter{cSubRespFromE2, 1},
6841 Counter{cRestSubNotifToXapp, 1},
6842 Counter{cRestSubFailNotifToXapp, 1},
6843 Counter{cRestSubDelReqFromXapp, 1},
6844 Counter{cSubDelReqToE2, 1},
6845 Counter{cSubDelRespFromE2, 1},
6846 Counter{cRestSubDelRespToXapp, 1},
6849 const e2Timeout int64 = 1
6850 const e2RetryCount int64 = 0
6851 const routingNeeded bool = false
6854 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6855 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6858 restSubId := xappConn1.SendRESTSubsReq(t, params)
6859 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6861 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6862 xappConn1.ExpectRESTNotification(t, restSubId)
6863 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
6864 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6865 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
6868 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6869 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6870 params.SetSubscriptionID(&restSubId)
6871 params.SetTimeToWait("w200ms")
6872 restSubId = xappConn1.SendRESTSubsReq(t, params)
6873 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6875 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
6876 xappConn1.ExpectRESTNotification(t, restSubId)
6877 // SubsResp is missing, e2SubsId will be 0
6878 zeroE2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6879 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", zeroE2SubsId)
6882 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6883 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6884 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6886 waitSubsCleanup(t, e2SubsId, 10)
6888 mainCtrl.VerifyCounterValues(t)
6889 //mainCtrl.VerifyAllClean(t)
6892 //-----------------------------------------------------------------------------
6893 // TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle
6896 // +-------+ +---------+ +---------+
6897 // | xapp | | submgr | | e2term |
6898 // +-------+ +---------+ +---------+
6901 // |---------------->| |
6903 // | RESTSubResp | |
6904 // |<----------------| |
6906 // | |------------->|
6909 // | |<-------------|
6912 // |<----------------| |
6915 // |---------------->| |
6917 // | RESTSubResp | |
6918 // |<----------------| |
6920 // | |------------->|
6922 // | Submgr restart |
6924 // | RESTSubDelReq | |
6925 // |---------------->| |
6928 // | |------------->|
6931 // | |<-------------|
6933 // | RESTSubDelResp | |
6934 // |<----------------| |
6936 //-----------------------------------------------------------------------------
6938 func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
6939 CaseBegin("TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle")
6941 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6942 Counter{cRestSubReqFromXapp, 2},
6943 Counter{cRestSubRespToXapp, 2},
6944 Counter{cSubReqToE2, 2},
6945 Counter{cSubRespFromE2, 1},
6946 Counter{cRestSubNotifToXapp, 1},
6947 Counter{cRestSubFailNotifToXapp, 1},
6948 Counter{cRestSubDelReqFromXapp, 1},
6949 Counter{cSubDelReqToE2, 1},
6950 Counter{cSubDelRespFromE2, 1},
6951 Counter{cRestSubDelRespToXapp, 1},
6954 // Remove possible existing subscription
6955 mainCtrl.removeExistingSubscriptions(t)
6957 const e2Timeout int64 = 1
6958 const e2RetryCount int64 = 0
6959 const routingNeeded bool = false
6962 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6963 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6964 // Create subscription
6965 restSubId := xappConn1.SendRESTSubsReq(t, params)
6966 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6968 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6969 xappConn1.ExpectRESTNotification(t, restSubId)
6970 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
6971 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6972 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
6974 // Check subscription
6975 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
6978 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6979 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6980 params.SetSubscriptionID(&restSubId)
6981 params.SetTimeToWait("w200ms")
6982 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
6983 restSubId = xappConn1.SendRESTSubsReq(t, params)
6984 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6986 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
6987 mainCtrl.SetResetTestFlag(t, false)
6989 // SubsResp is missing due to submgr restart
6991 mainCtrl.SimulateRestart(t)
6992 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
6994 // Check subscription
6995 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
6997 // Delete subscription
6998 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6999 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7000 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7002 //Wait that subs is cleaned
7003 waitSubsCleanup(t, e2SubsId, 10)
7005 mainCtrl.VerifyCounterValues(t)
7006 //mainCtrl.VerifyAllClean(t)
7009 ////////////////////////////////////////////////////////////////////////////////////
7010 // Services for UT cases
7011 ////////////////////////////////////////////////////////////////////////////////////
7012 const subReqCount int = 1
7013 const host string = "localhost"
7015 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
7017 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
7019 restSubId := fromXappConn.SendRESTSubsReq(t, params)
7020 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
7022 crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
7023 fromXappConn.ExpectRESTNotification(t, restSubId)
7024 toE2termConn.SendSubsResp(t, crereq1, cremsg1)
7025 e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
7026 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7028 return restSubId, e2SubsId
7031 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
7033 params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
7035 params.SetMeid(meid)
7037 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
7038 restSubId := xappConn2.SendRESTSubsReq(t, params)
7039 xappConn2.ExpectRESTNotification(t, restSubId)
7040 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
7041 e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
7042 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7044 return restSubId, e2SubsId
7047 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
7049 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7050 restSubId := xappConn1.SendRESTSubsReq(t, params)
7051 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
7053 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7054 xappConn1.ExpectRESTNotification(t, restSubId)
7055 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
7056 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7057 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7059 return restSubId, e2SubsId
7062 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
7063 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7064 restSubId := xappConn1.SendRESTSubsReq(t, params)
7066 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7067 fparams1 := &teststube2ap.E2StubSubsFailParams{}
7068 fparams1.Set(crereq1)
7069 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
7071 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
7072 xappConn1.ExpectRESTNotification(t, restSubId)
7073 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
7074 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7075 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
7077 return restSubId, e2SubsId
7080 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
7081 fromXappConn.SendRESTSubsDelReq(t, restSubId)
7082 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
7083 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
7086 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
7087 xappConn1.SendRESTSubsDelReq(t, restSubId)
7088 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7089 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7092 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
7093 xappConn2.SendRESTSubsDelReq(t, restSubId)
7094 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7095 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7098 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
7099 resp, _ := xapp.Subscription.QuerySubscriptions()
7100 assert.Equal(t, resp[0].SubscriptionID, e2SubsId)
7101 assert.Equal(t, resp[0].Meid, meid)
7102 assert.Equal(t, resp[0].ClientEndpoint, endpoint)
7105 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
7106 //Wait that subs is cleaned
7107 mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
7109 xappConn1.TestMsgChanEmpty(t)
7110 xappConn2.TestMsgChanEmpty(t)
7111 e2termConn1.TestMsgChanEmpty(t)
7112 mainCtrl.wait_registry_empty(t, timeout)
7115 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
7117 var e2SubsId []uint32
7119 for i := 0; i < count; i++ {
7120 xapp.Logger.Debug("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
7121 crereq, cremsg := toE2termConn.RecvSubsReq(t)
7122 fromXappConn.ExpectRESTNotification(t, restSubId)
7123 toE2termConn.SendSubsResp(t, crereq, cremsg)
7124 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
7125 e2SubsId = append(e2SubsId, instanceId)
7126 xapp.Logger.Debug("TEST: %v", e2SubsId)
7127 xapp.Logger.Debug("TEST: %d ===================================== END CRE ============================================", i+1)
7128 <-time.After(100 * time.Millisecond)
7133 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
7135 for i := 0; i < len(e2SubsIds); i++ {
7136 xapp.Logger.Debug("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
7137 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
7138 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
7139 <-time.After(1 * time.Second)
7140 xapp.Logger.Debug("TEST: %d ===================================== END DEL ============================================", i+1)
7141 <-time.After(100 * time.Millisecond)
7144 // Wait that subs is cleaned
7145 for i := 0; i < len(e2SubsIds); i++ {
7146 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)