2 ==================================================================================
3 Copyright (c) 2019 AT&T Intellectual Property.
4 Copyright (c) 2019 Nokia
6 Licensed under the Apache License, Version 2.0 (the "License");
7 you may not use this file except in compliance with the License.
8 You may obtain a copy of the License at
10 http://www.apache.org/licenses/LICENSE-2.0
12 Unless required by applicable law or agreed to in writing, software
13 distributed under the License is distributed on an "AS IS" BASIS,
14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 See the License for the specific language governing permissions and
16 limitations under the License.
17 ==================================================================================
28 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
29 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper"
30 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
31 "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststube2ap"
32 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
33 "github.com/stretchr/testify/assert"
36 func TestSuiteSetup(t *testing.T) {
37 // The effect of this call shall endure though the UT suite!
38 // If this causes any issues, the previous interface can be restored
40 // SetPackerIf(e2ap_wrapper.NewAsn1E2APPacker())
42 mainCtrl.InitAllCounterMap()
43 SetPackerIf(e2ap_wrapper.NewUtAsn1E2APPacker())
44 mainCtrl.c.restDuplicateCtrl.Init()
47 func TestRanStatusChangeViaSDLNotification(t *testing.T) {
49 // Current UT test cases use these ran names
50 xappRnibMock.CreateGnb("RAN_NAME_1", entities.ConnectionStatus_DISCONNECTED)
51 xappRnibMock.CreateGnb("RAN_NAME_11", entities.ConnectionStatus_DISCONNECTED)
52 xappRnibMock.CreateGnb("RAN_NAME_2", entities.ConnectionStatus_DISCONNECTED)
54 mainCtrl.c.e2IfState.ReadE2ConfigurationFromRnib()
55 mainCtrl.c.e2IfState.SubscribeChannels()
57 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
58 mainCtrl.SetE2State(t, "RAN_NAME_2_CONNECTED")
59 mainCtrl.SetE2State(t, "RAN_NAME_11_CONNECTED")
62 //-----------------------------------------------------------------------------
63 // TestRESTSubReqAfterE2ConnBreak
66 // +-------+ +---------+ +---------+
67 // | xapp | | submgr | | e2term |
68 // +-------+ +---------+ +---------+
70 // | [E2 Conn. DOWN] |
73 // |---------------->| |
75 // |<----------------| |
78 //-----------------------------------------------------------------------------
80 func TestRESTSubReqAfterE2ConnBreak(t *testing.T) {
81 CaseBegin("TestRESTSubReqAfterE2ConnBreak")
83 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
84 Counter{cRestSubReqFromXapp, 1},
85 Counter{cRestReqRejDueE2Down, 1},
88 // E2 disconnect after E2term has received response
89 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
91 const subReqCount int = 1
92 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
93 xappConn1.SendRESTSubsReq(t, params)
95 // Restore E2 connection for following test cases
96 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
98 mainCtrl.VerifyCounterValues(t)
99 mainCtrl.VerifyAllClean(t)
103 //-----------------------------------------------------------------------------
104 // TestRESTSubReqE2ConnBreak
107 // +-------+ +---------+ +---------+
108 // | xapp | | submgr | | e2term |
109 // +-------+ +---------+ +---------+
112 // |---------------->| |
114 // |<----------------| |
116 // | |------------->|
118 // | |<-------------|
120 // | [E2 Conn. DOWN] |
121 // | [Int. SUBS DELETE] |
123 // | RESTNotif(unsuccessful) |
124 // |<----------------| |
128 //-----------------------------------------------------------------------------
129 func TestRESTSubReqE2ConnBreak(t *testing.T) {
130 CaseBegin("TestRESTSubReqE2ConnBreak")
132 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
133 Counter{cRestSubReqFromXapp, 1},
134 Counter{cRestSubRespToXapp, 1},
135 Counter{cSubReqToE2, 1},
136 Counter{cSubRespFromE2, 1},
137 Counter{cRestSubFailNotifToXapp, 1},
141 const subReqCount int = 1
142 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
143 restSubId := xappConn1.SendRESTSubsReq(t, params)
145 crereq, cremsg := e2termConn1.RecvSubsReq(t)
146 xappConn1.ExpectRESTNotification(t, restSubId)
148 // E2 disconnect after E2term has received response
149 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
151 e2termConn1.SendSubsResp(t, crereq, cremsg)
152 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
154 <-time.After(time.Second * 1)
155 assert.Equal(t, 0, len(mainCtrl.c.registry.register))
156 assert.Equal(t, 0, len(mainCtrl.c.registry.restSubscriptions))
158 subIds, register, err := mainCtrl.c.ReadAllSubscriptionsFromSdl()
160 xapp.Logger.Error("%v", err)
162 assert.Equal(t, 65534, len(subIds)) // range 1-65535 , FFFF = 65535
163 assert.Equal(t, 0, len(register))
166 restSubscriptions, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
168 xapp.Logger.Error("%v", err)
170 assert.Equal(t, 0, len(restSubscriptions))
173 // Restore E2 connection for following test cases
174 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
176 // Wait that subs is cleaned
177 waitSubsCleanup(t, e2SubsId, 10)
178 mainCtrl.VerifyCounterValues(t)
179 mainCtrl.VerifyAllClean(t)
182 //-----------------------------------------------------------------------------
183 // TestRESTSubscriptionDeleteAfterE2ConnectionBreak
186 // +-------+ +---------+ +---------+
187 // | xapp | | submgr | | e2term |
188 // +-------+ +---------+ +---------+
192 // | [E2 Conn. DOWN] |
194 // | RESTSubDelReq | |
195 // |---------------->| |
197 // | RESTSubDelResp | |
198 // |<----------------| |
200 // | [No valid subscription found] |
203 //-----------------------------------------------------------------------------
204 func TestRESTSubscriptionDeleteAfterE2ConnectionBreak(t *testing.T) {
205 xapp.Logger.Debug("TEST: TestRESTSubscriptionDeleteAfterE2ConnectionBreak")
207 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
208 Counter{cRestSubReqFromXapp, 1},
209 Counter{cRestSubRespToXapp, 1},
210 Counter{cSubReqToE2, 1},
211 Counter{cSubRespFromE2, 1},
212 Counter{cRestSubNotifToXapp, 1},
213 Counter{cRestSubDelReqFromXapp, 1},
214 Counter{cRestSubDelRespToXapp, 1},
218 var params *teststube2ap.RESTSubsReqParams = nil
219 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
221 // E2 disconnect after E2term has received response
222 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
225 xappConn1.SendRESTSubsDelReq(t, &restSubId)
227 <-time.After(time.Second * 1)
228 assert.Equal(t, 0, len(mainCtrl.c.registry.register))
229 assert.Equal(t, 0, len(mainCtrl.c.registry.restSubscriptions))
231 subIds, register, err := mainCtrl.c.ReadAllSubscriptionsFromSdl()
233 xapp.Logger.Error("%v", err)
235 assert.Equal(t, 65534, len(subIds)) // range 1-65535 , FFFF = 65535
236 assert.Equal(t, 0, len(register))
239 restSubscriptions, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
241 xapp.Logger.Error("%v", err)
243 assert.Equal(t, 0, len(restSubscriptions))
246 // Restore E2 connection for following test cases
247 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
249 // Wait that subs is cleaned
250 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
252 xappConn1.TestMsgChanEmpty(t)
253 e2termConn1.TestMsgChanEmpty(t)
254 mainCtrl.wait_registry_empty(t, 10)
255 mainCtrl.VerifyCounterValues(t)
256 mainCtrl.VerifyAllClean(t)
259 //-----------------------------------------------------------------------------
260 // TestRESTOtherE2ConnectionChanges
264 // +-------+ +---------+ +---------+
265 // | xapp | | submgr | | e2term |
266 // +-------+ +---------+ +---------+
270 // | [E2 CONNECTED_SETUP_FAILED] |
271 // | [E2 CONNECTING] |
272 // | [E2 SHUTTING_DOWN] |
273 // | [E2 SHUT_DOWN] |
278 //-----------------------------------------------------------------------------
279 func TestRESTOtherE2ConnectionChanges(t *testing.T) {
280 xapp.Logger.Debug("TEST: TestRESTOtherE2ConnectionChanges")
282 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
283 Counter{cRestSubReqFromXapp, 1},
284 Counter{cRestSubRespToXapp, 1},
285 Counter{cSubReqToE2, 1},
286 Counter{cSubRespFromE2, 1},
287 Counter{cRestSubNotifToXapp, 1},
288 Counter{cRestSubDelReqFromXapp, 1},
289 Counter{cSubDelReqToE2, 1},
290 Counter{cSubDelRespFromE2, 1},
291 Counter{cRestSubDelRespToXapp, 1},
295 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
296 restSubId := xappConn1.SendRESTSubsReq(t, params)
298 crereq, cremsg := e2termConn1.RecvSubsReq(t)
299 xappConn1.ExpectRESTNotification(t, restSubId)
300 e2termConn1.SendSubsResp(t, crereq, cremsg)
301 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
303 // Submgr should not react any other connection state changes than CONNECTED and DISCONNECTED
304 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED_SETUP_FAILED")
305 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTING")
306 mainCtrl.SetE2State(t, "RAN_NAME_1_SHUTTING_DOWN")
307 mainCtrl.SetE2State(t, "RAN_NAME_1_SHUT_DOWN")
310 xappConn1.SendRESTSubsDelReq(t, &restSubId)
311 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
312 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
314 // Restore E2 connection for following test cases
315 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
317 // Wait that subs is cleaned
318 waitSubsCleanup(t, e2SubsId, 10)
319 mainCtrl.VerifyCounterValues(t)
320 mainCtrl.VerifyAllClean(t)
323 //-----------------------------------------------------------------------------
324 // TestRESTSubReqAndDeleteOkWithE2apUtWrapper
327 // +-------+ +---------+ +---------+ +---------+
328 // | xapp | | submgr | | e2term | | rtmgr |
329 // +-------+ +---------+ +---------+ +---------+
331 // | RESTSubReq | | |
332 // |---------------->| | |
333 // | | RouteCreate | |
334 // | |--------------------------->| // The order of these events may vary
336 // | RESTSubResp | | | // The order of these events may vary
337 // |<----------------| | |
338 // | | RouteResponse| |
339 // | |<---------------------------| // The order of these events may vary
342 // | |------------->| | // The order of these events may vary
345 // | |<-------------| |
346 // | RESTNotif1 | | |
347 // |<----------------| | |
349 // | RESTSubDelReq | | |
350 // |---------------->| | |
352 // | |------------->| |
354 // | RESTSubDelResp| | |
355 // |<----------------| | |
357 // | | SubDelResp | |
358 // | |<-------------| |
362 //-----------------------------------------------------------------------------
363 func TestRESTSubReqAndDeleteOkWithE2apUtWrapper(t *testing.T) {
365 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
367 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
369 waitSubsCleanup(t, e2SubsId, 10)
370 mainCtrl.VerifyAllClean(t)
373 //-----------------------------------------------------------------------------
374 // TestRESTSubReqAndE1apDeleteReqPackingError
377 // +-------+ +---------+ +---------+ +---------+
378 // | xapp | | submgr | | e2term | | rtmgr |
379 // +-------+ +---------+ +---------+ +---------+
381 // | RESTSubReq | | |
382 // |---------------->| | |
383 // | | RouteCreate | |
384 // | |--------------------------->| // The order of these events may vary
386 // | RESTSubResp | | | // The order of these events may vary
387 // |<----------------| | |
388 // | | RouteResponse| |
389 // | |<---------------------------| // The order of these events may vary
392 // | |------------->| | // The order of these events may vary
395 // | |<-------------| |
396 // | RESTNotif1 | | |
397 // |<----------------| | |
399 // | RESTSubDelReq | | |
400 // |---------------->| | |
402 // | RESTSubDelResp| | |
403 // |<----------------| | |
407 //-----------------------------------------------------------------------------
408 func TestRESTSubReqAndE1apDeleteReqPackingError(t *testing.T) {
410 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
412 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, false)
413 xappConn1.SendRESTSubsDelReq(t, &restSubId)
414 defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, true)
416 waitSubsCleanup(t, e2SubsId, 10)
417 mainCtrl.VerifyAllClean(t)
420 //-----------------------------------------------------------------------------
421 // TestRESTSubReqAndE1apDeleteRespUnpackingError
424 // +-------+ +---------+ +---------+ +---------+
425 // | xapp | | submgr | | e2term | | rtmgr |
426 // +-------+ +---------+ +---------+ +---------+
428 // | RESTSubReq | | |
429 // |---------------->| | |
430 // | | RouteCreate | |
431 // | |--------------------------->| // The order of these events may vary
433 // | RESTSubResp | | | // The order of these events may vary
434 // |<----------------| | |
435 // | | RouteResponse| |
436 // | |<---------------------------| // The order of these events may vary
439 // | |------------->| | // The order of these events may vary
442 // | |<-------------| |
443 // | RESTNotif1 | | |
444 // |<----------------| | |
446 // | RESTSubDelReq | | |
447 // |---------------->| | |
449 // | |------------->| |
451 // | RESTSubDelResp| | |
452 // |<----------------| | | // The order of these events may vary
454 // | | SubDelResp | |
455 // | |<-------------| | // 1.st NOK
458 // | |------------->| |
460 // | | SubDelResp | |
461 // | |<-------------| | // 2.nd NOK
463 //-----------------------------------------------------------------------------
465 func TestRESTSubReqAndE1apDeleteRespUnpackingError(t *testing.T) {
467 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
469 xappConn1.SendRESTSubsDelReq(t, &restSubId)
470 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, false)
471 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
472 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
474 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
475 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
477 defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, true)
479 waitSubsCleanup(t, e2SubsId, 10)
480 mainCtrl.VerifyAllClean(t)
483 //-----------------------------------------------------------------------------
484 // TestSubReqAndRouteNok
487 // +-------+ +---------+ +---------+
488 // | xapp | | submgr | | rtmgr |
489 // +-------+ +---------+ +---------+
492 // |------------->| |
495 // | |------------->|
499 // | |<-------------|
501 // | [SUBS INT DELETE] |
504 //-----------------------------------------------------------------------------
506 func TestSubReqAndRouteNok(t *testing.T) {
507 CaseBegin("TestSubReqAndRouteNok")
509 // Init counter check
510 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
511 Counter{cSubReqFromXapp, 1},
512 Counter{cRouteCreateFail, 1},
515 waiter := rtmgrHttp.AllocNextEvent(false)
516 newSubsId := mainCtrl.get_registry_next_subid(t)
517 xappConn1.SendSubsReq(t, nil, nil)
520 //Wait that subs is cleaned
521 mainCtrl.wait_subs_clean(t, newSubsId, 10)
523 xappConn1.TestMsgChanEmpty(t)
524 xappConn2.TestMsgChanEmpty(t)
525 e2termConn1.TestMsgChanEmpty(t)
526 mainCtrl.wait_registry_empty(t, 10)
528 <-time.After(1 * time.Second)
529 mainCtrl.VerifyCounterValues(t)
532 //-----------------------------------------------------------------------------
533 // TestSubReqAndRouteUpdateNok
536 // +-------+ +-------+ +---------+ +---------+
537 // | xapp2 | | xapp1 | | submgr | | rtmgr |
538 // +-------+ +-------+ +---------+ +---------+
540 // | [SUBS CREATE] | |
544 // | SubReq (mergeable) | |
545 // |--------------------------->| | |
547 // | | | RouteUpdate |
548 // | | |------------->|
550 // | | | RouteUpdate |
551 // | | | status:400 |
552 // | | |<-------------|
554 // | [SUBS INT DELETE] | |
557 // | [SUBS DELETE] | |
560 func TestSubReqAndRouteUpdateNok(t *testing.T) {
561 CaseBegin("TestSubReqAndRouteUpdateNok")
563 // Init counter check
564 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
565 Counter{cSubReqFromXapp, 2},
566 Counter{cSubReqToE2, 1},
567 Counter{cSubRespFromE2, 1},
568 Counter{cSubRespToXapp, 1},
569 Counter{cRouteCreateUpdateFail, 1},
570 Counter{cSubDelReqFromXapp, 1},
571 Counter{cSubDelReqToE2, 1},
572 Counter{cSubDelRespFromE2, 1},
573 Counter{cSubDelRespToXapp, 1},
576 cretrans := xappConn1.SendSubsReq(t, nil, nil)
577 crereq, cremsg := e2termConn1.RecvSubsReq(t)
578 e2termConn1.SendSubsResp(t, crereq, cremsg)
579 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
581 resp, _ := xapp.Subscription.QuerySubscriptions()
582 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
583 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
584 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
586 waiter := rtmgrHttp.AllocNextEvent(false)
587 newSubsId := mainCtrl.get_registry_next_subid(t)
588 xappConn2.SendSubsReq(t, nil, nil)
591 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
592 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
594 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
595 xappConn1.RecvSubsDelResp(t, deltrans)
597 //Wait that subs is cleaned
598 mainCtrl.wait_subs_clean(t, newSubsId, 10)
599 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
601 xappConn1.TestMsgChanEmpty(t)
602 xappConn2.TestMsgChanEmpty(t)
603 e2termConn1.TestMsgChanEmpty(t)
604 mainCtrl.wait_registry_empty(t, 10)
606 mainCtrl.VerifyCounterValues(t)
609 //-----------------------------------------------------------------------------
610 // TestSubDelReqAndRouteDeleteNok
613 // +-------+ +---------+ +---------+ +---------+
614 // | xapp | | submgr | | e2term | | rtmgr |
615 // +-------+ +---------+ +---------+ +---------+
617 // | [SUBS CREATE] | |
622 // |------------->| | |
624 // | |------------->| |
626 // | |<-------------| |
628 // |<-------------| | |
629 // | | RouteDelete | |
630 // | |---------------------------->|
632 // | | RouteDelete | |
633 // | | status:400 | |
634 // | |<----------------------------|
636 func TestSubDelReqAndRouteDeleteNok(t *testing.T) {
637 CaseBegin("TestSubDelReqAndRouteDeleteNok")
639 // Init counter check
640 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
641 Counter{cSubReqFromXapp, 1},
642 Counter{cSubReqToE2, 1},
643 Counter{cSubRespFromE2, 1},
644 Counter{cSubRespToXapp, 1},
645 Counter{cSubDelReqFromXapp, 1},
646 Counter{cRouteDeleteFail, 1},
647 Counter{cSubDelReqToE2, 1},
648 Counter{cSubDelRespFromE2, 1},
649 Counter{cSubDelRespToXapp, 1},
652 cretrans := xappConn1.SendSubsReq(t, nil, nil)
653 crereq, cremsg := e2termConn1.RecvSubsReq(t)
654 e2termConn1.SendSubsResp(t, crereq, cremsg)
655 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
657 resp, _ := xapp.Subscription.QuerySubscriptions()
658 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
659 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
660 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
662 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
663 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
665 waiter := rtmgrHttp.AllocNextEvent(false)
666 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
669 xappConn1.RecvSubsDelResp(t, deltrans)
671 //Wait that subs is cleaned
672 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
674 xappConn1.TestMsgChanEmpty(t)
675 xappConn2.TestMsgChanEmpty(t)
676 e2termConn1.TestMsgChanEmpty(t)
677 mainCtrl.wait_registry_empty(t, 10)
679 mainCtrl.VerifyCounterValues(t)
682 //-----------------------------------------------------------------------------
683 // TestSubMergeDelAndRouteUpdateNok
685 // +-------+ +-------+ +---------+ +---------+
686 // | xapp2 | | xapp1 | | submgr | | e2term |
687 // +-------+ +-------+ +---------+ +---------+
692 // | |------------->| |
695 // | | |------------->|
697 // | | |<-------------|
699 // | |<-------------| |
702 // |--------------------------->| |
705 // |<---------------------------| |
707 // | | SubDelReq 1 | |
708 // | |------------->| |
709 // | | | RouteUpdate |
710 // | | |-----> rtmgr |
712 // | | | RouteUpdate |
713 // | | | status:400 |
714 // | | |<----- rtmgr |
716 // | | SubDelResp 1 | |
717 // | |<-------------| |
720 // |--------------------------->| |
722 // | | | SubDelReq 2 |
723 // | | |------------->|
725 // | | | SubDelReq 2 |
726 // | | |------------->|
728 // | SubDelResp 2 | |
729 // |<---------------------------| |
731 //-----------------------------------------------------------------------------
732 func TestSubMergeDelAndRouteUpdateNok(t *testing.T) {
733 CaseBegin("TestSubMergeDelAndRouteUpdateNok")
735 // Init counter check
736 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
737 Counter{cSubReqFromXapp, 2},
738 Counter{cMergedSubscriptions, 1},
739 Counter{cSubReqToE2, 1},
740 Counter{cSubRespFromE2, 1},
741 Counter{cSubRespToXapp, 2},
742 Counter{cSubDelReqFromXapp, 2},
743 Counter{cRouteDeleteUpdateFail, 1},
744 Counter{cSubDelReqToE2, 1},
745 Counter{cSubDelRespFromE2, 1},
746 Counter{cSubDelRespToXapp, 2},
747 Counter{cUnmergedSubscriptions, 1},
751 rparams1 := &teststube2ap.E2StubSubsReqParams{}
753 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
754 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
755 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
756 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
759 rparams2 := &teststube2ap.E2StubSubsReqParams{}
761 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
762 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
764 resp, _ := xapp.Subscription.QuerySubscriptions()
765 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
766 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
767 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
770 waiter := rtmgrHttp.AllocNextEvent(false)
771 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
774 xappConn1.RecvSubsDelResp(t, deltrans1)
777 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
778 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
779 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
780 xappConn2.RecvSubsDelResp(t, deltrans2)
781 //Wait that subs is cleaned
782 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
784 xappConn1.TestMsgChanEmpty(t)
785 xappConn2.TestMsgChanEmpty(t)
786 e2termConn1.TestMsgChanEmpty(t)
787 mainCtrl.wait_registry_empty(t, 10)
789 mainCtrl.VerifyCounterValues(t)
792 //-----------------------------------------------------------------------------
794 //-----------------------------------------------------------------------------
795 // TestSubReqAndSubDelOk
798 // +-------+ +---------+ +---------+
799 // | xapp | | submgr | | e2term |
800 // +-------+ +---------+ +---------+
803 // |------------->| |
806 // | |------------->|
809 // | |<-------------|
812 // |<-------------| |
816 // |------------->| |
819 // | |------------->|
822 // | |<-------------|
825 // |<-------------| |
827 //-----------------------------------------------------------------------------
828 func TestSubReqAndSubDelOk(t *testing.T) {
829 CaseBegin("TestSubReqAndSubDelOk")
831 // Init counter check
832 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
833 Counter{cSubReqFromXapp, 1},
834 Counter{cSubReqToE2, 1},
835 Counter{cSubRespFromE2, 1},
836 Counter{cSubRespToXapp, 1},
837 Counter{cSubDelReqFromXapp, 1},
838 Counter{cSubDelReqToE2, 1},
839 Counter{cSubDelRespFromE2, 1},
840 Counter{cSubDelRespToXapp, 1},
843 cretrans := xappConn1.SendSubsReq(t, nil, nil)
844 crereq, cremsg := e2termConn1.RecvSubsReq(t)
845 e2termConn1.SendSubsResp(t, crereq, cremsg)
846 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
848 resp, _ := xapp.Subscription.QuerySubscriptions()
849 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
850 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
851 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
853 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
854 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
856 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
857 xappConn1.RecvSubsDelResp(t, deltrans)
859 //Wait that subs is cleaned
860 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
862 xappConn1.TestMsgChanEmpty(t)
863 xappConn2.TestMsgChanEmpty(t)
864 e2termConn1.TestMsgChanEmpty(t)
865 mainCtrl.wait_registry_empty(t, 10)
867 mainCtrl.VerifyCounterValues(t)
870 //-----------------------------------------------------------------------------
871 // TestSubReqRetransmission
874 // +-------+ +---------+ +---------+
875 // | xapp | | submgr | | e2term |
876 // +-------+ +---------+ +---------+
879 // |------------->| |
882 // | |------------->|
886 // |------------->| |
889 // | |<-------------|
892 // |<-------------| |
897 //-----------------------------------------------------------------------------
898 func TestSubReqRetransmission(t *testing.T) {
899 CaseBegin("TestSubReqRetransmission")
902 cretrans := xappConn1.SendSubsReq(t, nil, nil)
903 crereq, cremsg := e2termConn1.RecvSubsReq(t)
905 seqBef := mainCtrl.get_msgcounter(t)
906 xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq
907 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
909 // hack as there is no real way to see has message be handled.
910 // Previuos counter check just tells that is has been received by submgr
911 // --> artificial delay
912 <-time.After(1 * time.Second)
913 e2termConn1.SendSubsResp(t, crereq, cremsg)
914 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
917 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
918 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
919 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
920 xappConn1.RecvSubsDelResp(t, deltrans)
922 //Wait that subs is cleaned
923 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
925 xappConn1.TestMsgChanEmpty(t)
926 xappConn2.TestMsgChanEmpty(t)
927 e2termConn1.TestMsgChanEmpty(t)
928 mainCtrl.wait_registry_empty(t, 10)
931 //-----------------------------------------------------------------------------
932 // TestSubDelReqRetransmission
935 // +-------+ +---------+ +---------+
936 // | xapp | | submgr | | e2term |
937 // +-------+ +---------+ +---------+
943 // |------------->| |
946 // | |------------->|
951 // |------------->| |
954 // | |<-------------|
957 // |<-------------| |
959 //-----------------------------------------------------------------------------
960 func TestSubDelReqRetransmission(t *testing.T) {
961 CaseBegin("TestSubDelReqRetransmission")
964 cretrans := xappConn1.SendSubsReq(t, nil, nil)
965 crereq, cremsg := e2termConn1.RecvSubsReq(t)
966 e2termConn1.SendSubsResp(t, crereq, cremsg)
967 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
970 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
971 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
973 seqBef := mainCtrl.get_msgcounter(t)
974 xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq
975 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
977 // hack as there is no real way to see has message be handled.
978 // Previuos counter check just tells that is has been received by submgr
979 // --> artificial delay
980 <-time.After(1 * time.Second)
982 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
983 xappConn1.RecvSubsDelResp(t, deltrans)
985 //Wait that subs is cleaned
986 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
988 xappConn1.TestMsgChanEmpty(t)
989 xappConn2.TestMsgChanEmpty(t)
990 e2termConn1.TestMsgChanEmpty(t)
991 mainCtrl.wait_registry_empty(t, 10)
994 //-----------------------------------------------------------------------------
995 // TestSubDelReqCollision
998 // +-------+ +---------+ +---------+
999 // | xapp | | submgr | | e2term |
1000 // +-------+ +---------+ +---------+
1002 // | [SUBS CREATE] |
1005 // | SubDelReq 1 | |
1006 // |------------->| |
1008 // | | SubDelReq 1 |
1009 // | |------------->|
1011 // | SubDelReq 2 | |
1014 // |------------->| |
1016 // | | SubDelResp 1 |
1017 // | |<-------------|
1019 // | SubDelResp 1 | |
1020 // |<-------------| |
1022 // | SubDelResp 2 | |
1023 // |<-------------| |
1025 //-----------------------------------------------------------------------------
1027 func TestSubDelReqCollision(t *testing.T) {
1028 CaseBegin("TestSubDelReqCollision")
1031 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1032 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1033 e2termConn1.SendSubsResp(t, crereq, cremsg)
1034 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1037 xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1038 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1040 // Subs Delete colliding
1041 seqBef := mainCtrl.get_msgcounter(t)
1042 deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1043 xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq
1044 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
1046 // hack as there is no real way to see has message be handled.
1047 // Previuos counter check just tells that is has been received by submgr
1048 // --> artificial delay
1049 <-time.After(1 * time.Second)
1051 // Del resp for first and second
1052 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1054 // don't care in which order responses are received
1055 xappConn1.RecvSubsDelResp(t, nil)
1056 xappConn1.RecvSubsDelResp(t, nil)
1058 //Wait that subs is cleaned
1059 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1061 xappConn1.TestMsgChanEmpty(t)
1062 xappConn2.TestMsgChanEmpty(t)
1063 e2termConn1.TestMsgChanEmpty(t)
1064 mainCtrl.wait_registry_empty(t, 10)
1067 //-----------------------------------------------------------------------------
1068 // TestSubReqAndSubDelOkTwoParallel
1071 // +-------+ +-------+ +---------+ +---------+
1072 // | xapp | | xapp | | submgr | | e2term |
1073 // +-------+ +-------+ +---------+ +---------+
1078 // | |------------->| |
1081 // | | |------------->|
1084 // |------------------------>| |
1087 // | | |------------->|
1090 // | | |<-------------|
1092 // | |<-------------| |
1095 // | | |<-------------|
1097 // |<------------------------| |
1099 // | | [SUBS 1 DELETE] |
1101 // | | [SUBS 2 DELETE] |
1104 //-----------------------------------------------------------------------------
1106 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
1107 CaseBegin("TestSubReqAndSubDelOkTwoParallel")
1110 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1112 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1113 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1116 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1119 rparams2.Req.EventTriggerDefinition.Data.Length = 1
1120 rparams2.Req.EventTriggerDefinition.Data.Data = make([]uint8, rparams2.Req.EventTriggerDefinition.Data.Length)
1121 rparams2.Req.EventTriggerDefinition.Data.Data[0] = 2
1123 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1124 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1127 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1128 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1131 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1132 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1135 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1136 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1137 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1138 xappConn1.RecvSubsDelResp(t, deltrans1)
1139 //Wait that subs is cleaned
1140 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1143 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1144 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1145 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1146 xappConn2.RecvSubsDelResp(t, deltrans2)
1147 //Wait that subs is cleaned
1148 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1150 xappConn1.TestMsgChanEmpty(t)
1151 xappConn2.TestMsgChanEmpty(t)
1152 e2termConn1.TestMsgChanEmpty(t)
1153 mainCtrl.wait_registry_empty(t, 10)
1156 //-----------------------------------------------------------------------------
1157 // TestSameSubsDiffRan
1158 // Same subscription to different RANs
1161 // +-------+ +---------+ +---------+
1162 // | xapp | | submgr | | e2term |
1163 // +-------+ +---------+ +---------+
1168 // |------------->| |
1171 // | |------------->|
1173 // | | SubResp(r1) |
1174 // | |<-------------|
1176 // | SubResp(r1) | |
1177 // |<-------------| |
1180 // |------------->| |
1183 // | |------------->|
1185 // | | SubResp(r2) |
1186 // | |<-------------|
1188 // | SubResp(r2) | |
1189 // |<-------------| |
1191 // | [SUBS r1 DELETE] |
1193 // | [SUBS r2 DELETE] |
1196 //-----------------------------------------------------------------------------
1197 func TestSameSubsDiffRan(t *testing.T) {
1198 CaseBegin("TestSameSubsDiffRan")
1201 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1202 xappConn1.SendSubsReq(t, nil, cretrans1)
1203 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1204 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1205 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1208 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
1209 xappConn1.SendSubsReq(t, nil, cretrans2)
1210 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1211 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1212 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1215 deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1216 xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
1217 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1218 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1219 xappConn1.RecvSubsDelResp(t, deltrans1)
1220 //Wait that subs is cleaned
1221 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1224 deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
1225 xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
1226 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1227 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1228 xappConn1.RecvSubsDelResp(t, deltrans2)
1229 //Wait that subs is cleaned
1230 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1232 xappConn1.TestMsgChanEmpty(t)
1233 xappConn2.TestMsgChanEmpty(t)
1234 e2termConn1.TestMsgChanEmpty(t)
1235 mainCtrl.wait_registry_empty(t, 10)
1238 //-----------------------------------------------------------------------------
1239 // TestSubReqRetryInSubmgr
1242 // +-------+ +---------+ +---------+
1243 // | xapp | | submgr | | e2term |
1244 // +-------+ +---------+ +---------+
1247 // |------------->| |
1250 // | |------------->|
1254 // | |------------->|
1257 // | |<-------------|
1260 // |<-------------| |
1262 // | [SUBS DELETE] |
1265 //-----------------------------------------------------------------------------
1267 func TestSubReqRetryInSubmgr(t *testing.T) {
1268 CaseBegin("TestSubReqRetryInSubmgr start")
1270 // Init counter check
1271 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1272 Counter{cSubReqFromXapp, 1},
1273 Counter{cSubReqToE2, 1},
1274 Counter{cSubReqTimerExpiry, 1},
1275 Counter{cSubReReqToE2, 1},
1276 Counter{cSubRespFromE2, 1},
1277 Counter{cSubRespToXapp, 1},
1278 Counter{cSubDelReqFromXapp, 1},
1279 Counter{cSubDelReqToE2, 1},
1280 Counter{cSubDelRespFromE2, 1},
1281 Counter{cSubDelRespToXapp, 1},
1284 // Xapp: Send SubsReq
1285 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1287 // E2t: Receive 1st SubsReq
1288 e2termConn1.RecvSubsReq(t)
1290 // E2t: Receive 2nd SubsReq and send SubsResp
1291 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1292 e2termConn1.SendSubsResp(t, crereq, cremsg)
1294 // Xapp: Receive SubsResp
1295 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1297 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1298 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1299 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1300 xappConn1.RecvSubsDelResp(t, deltrans)
1302 // Wait that subs is cleaned
1303 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1305 xappConn1.TestMsgChanEmpty(t)
1306 xappConn2.TestMsgChanEmpty(t)
1307 e2termConn1.TestMsgChanEmpty(t)
1308 mainCtrl.wait_registry_empty(t, 10)
1310 mainCtrl.VerifyCounterValues(t)
1313 //-----------------------------------------------------------------------------
1314 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
1317 // +-------+ +---------+ +---------+
1318 // | xapp | | submgr | | e2term |
1319 // +-------+ +---------+ +---------+
1322 // |------------->| |
1325 // | |------------->|
1329 // | |------------->|
1332 // | |------------->|
1335 // | |<-------------|
1338 //-----------------------------------------------------------------------------
1339 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
1340 CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
1342 // Init counter check
1343 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1344 Counter{cSubReqFromXapp, 1},
1345 Counter{cSubReqToE2, 1},
1346 Counter{cSubReReqToE2, 1},
1347 Counter{cSubReqTimerExpiry, 2},
1348 Counter{cSubDelReqToE2, 1},
1349 Counter{cSubDelRespFromE2, 1},
1352 // Xapp: Send SubsReq
1353 xappConn1.SendSubsReq(t, nil, nil)
1355 // E2t: Receive 1st SubsReq
1356 e2termConn1.RecvSubsReq(t)
1358 // E2t: Receive 2nd SubsReq
1359 e2termConn1.RecvSubsReq(t)
1361 // E2t: Send receive SubsDelReq and send SubsResp
1362 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1363 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1365 // Wait that subs is cleaned
1366 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 10)
1368 xappConn1.TestMsgChanEmpty(t)
1369 xappConn2.TestMsgChanEmpty(t)
1370 e2termConn1.TestMsgChanEmpty(t)
1371 mainCtrl.wait_registry_empty(t, 10)
1373 mainCtrl.VerifyCounterValues(t)
1376 //-----------------------------------------------------------------------------
1377 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
1380 // +-------+ +---------+ +---------+
1381 // | xapp | | submgr | | e2term |
1382 // +-------+ +---------+ +---------+
1385 // |------------->| |
1388 // | |------------->|
1392 // | |------------->|
1395 // | |------------->|
1399 // | |------------->|
1403 //-----------------------------------------------------------------------------
1405 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
1406 CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
1408 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1409 Counter{cSubReqFromXapp, 1},
1410 Counter{cSubReqToE2, 1},
1411 Counter{cSubReReqToE2, 1},
1412 Counter{cSubReqTimerExpiry, 2},
1413 Counter{cSubDelReqToE2, 1},
1414 Counter{cSubDelReReqToE2, 1},
1415 Counter{cSubDelReqTimerExpiry, 2},
1418 // Xapp: Send SubsReq
1419 xappConn1.SendSubsReq(t, nil, nil)
1421 // E2t: Receive 1st SubsReq
1422 e2termConn1.RecvSubsReq(t)
1424 // E2t: Receive 2nd SubsReq
1425 e2termConn1.RecvSubsReq(t)
1427 // E2t: Receive 1st SubsDelReq
1428 e2termConn1.RecvSubsDelReq(t)
1430 // E2t: Receive 2nd SubsDelReq
1431 delreq, _ := e2termConn1.RecvSubsDelReq(t)
1433 // Wait that subs is cleaned
1434 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 15)
1436 xappConn1.TestMsgChanEmpty(t)
1437 xappConn2.TestMsgChanEmpty(t)
1438 e2termConn1.TestMsgChanEmpty(t)
1439 mainCtrl.wait_registry_empty(t, 10)
1441 mainCtrl.VerifyCounterValues(t)
1444 //-----------------------------------------------------------------------------
1445 // TestSubReqSubFailRespInSubmgr
1448 // +-------+ +---------+ +---------+
1449 // | xapp | | submgr | | e2term |
1450 // +-------+ +---------+ +---------+
1453 // |------------->| |
1456 // | |------------->|
1459 // | |<-------------|
1462 // |<-------------| |
1465 //-----------------------------------------------------------------------------
1467 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1468 CaseBegin("TestSubReqSubFailRespInSubmgr start")
1470 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1471 Counter{cSubReqFromXapp, 1},
1472 Counter{cSubReqToE2, 1},
1473 Counter{cSubFailFromE2, 1},
1474 Counter{cSubFailToXapp, 1},
1477 // Xapp: Send SubsReq
1478 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1480 // E2t: Receive SubsReq and send SubsFail (first)
1481 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1482 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1483 fparams1.Set(crereq1)
1484 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1486 // Xapp: Receive SubsFail
1487 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
1489 // Wait that subs is cleaned
1490 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1492 xappConn1.TestMsgChanEmpty(t)
1493 xappConn2.TestMsgChanEmpty(t)
1494 e2termConn1.TestMsgChanEmpty(t)
1495 mainCtrl.wait_registry_empty(t, 10)
1497 mainCtrl.VerifyCounterValues(t)
1500 //-----------------------------------------------------------------------------
1501 // TestSubDelReqRetryInSubmgr
1504 // +-------+ +---------+ +---------+
1505 // | xapp | | submgr | | e2term |
1506 // +-------+ +---------+ +---------+
1508 // | [SUBS CREATE] |
1512 // |------------->| |
1515 // | |------------->|
1518 // | |------------->|
1521 // | |<-------------|
1524 // |<-------------| |
1526 //-----------------------------------------------------------------------------
1528 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1530 CaseBegin("TestSubDelReqRetryInSubmgr start")
1533 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1534 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1535 e2termConn1.SendSubsResp(t, crereq, cremsg)
1536 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1539 // Xapp: Send SubsDelReq
1540 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1542 // E2t: Receive 1st SubsDelReq
1543 e2termConn1.RecvSubsDelReq(t)
1545 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1546 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1547 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1549 // Xapp: Receive SubsDelResp
1550 xappConn1.RecvSubsDelResp(t, deltrans)
1552 // Wait that subs is cleaned
1553 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1555 xappConn1.TestMsgChanEmpty(t)
1556 xappConn2.TestMsgChanEmpty(t)
1557 e2termConn1.TestMsgChanEmpty(t)
1558 mainCtrl.wait_registry_empty(t, 10)
1561 //-----------------------------------------------------------------------------
1562 // TestSubDelReqTwoRetriesNoRespInSubmgr
1565 // +-------+ +---------+ +---------+
1566 // | xapp | | submgr | | e2term |
1567 // +-------+ +---------+ +---------+
1569 // | [SUBS CREATE] |
1573 // |------------->| |
1576 // | |------------->|
1579 // | |------------->|
1583 // |<-------------| |
1585 //-----------------------------------------------------------------------------
1587 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1589 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
1592 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1593 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1594 e2termConn1.SendSubsResp(t, crereq, cremsg)
1595 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1598 // Xapp: Send SubsDelReq
1599 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1601 // E2t: Receive 1st SubsDelReq
1602 e2termConn1.RecvSubsDelReq(t)
1604 // E2t: Receive 2nd SubsDelReq
1605 e2termConn1.RecvSubsDelReq(t)
1607 // Xapp: Receive SubsDelResp
1608 xappConn1.RecvSubsDelResp(t, deltrans)
1610 // Wait that subs is cleaned
1611 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1613 xappConn1.TestMsgChanEmpty(t)
1614 xappConn2.TestMsgChanEmpty(t)
1615 e2termConn1.TestMsgChanEmpty(t)
1616 mainCtrl.wait_registry_empty(t, 10)
1619 //-----------------------------------------------------------------------------
1620 // TestSubDelReqSubDelFailRespInSubmgr
1623 // +-------+ +---------+ +---------+
1624 // | xapp | | submgr | | e2term |
1625 // +-------+ +---------+ +---------+
1627 // | [SUBS CREATE] |
1631 // |------------->| |
1634 // | |------------->|
1637 // | |<-------------|
1640 // |<-------------| |
1643 //-----------------------------------------------------------------------------
1645 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1646 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1648 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1649 Counter{cSubReqFromXapp, 1},
1650 Counter{cSubReqToE2, 1},
1651 Counter{cSubRespFromE2, 1},
1652 Counter{cSubRespToXapp, 1},
1653 Counter{cSubDelReqFromXapp, 1},
1654 Counter{cSubDelReqToE2, 1},
1655 Counter{cSubDelFailFromE2, 1},
1656 Counter{cSubDelRespToXapp, 1},
1660 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1661 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1662 e2termConn1.SendSubsResp(t, crereq, cremsg)
1663 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1665 // Xapp: Send SubsDelReq
1666 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1668 // E2t: Send receive SubsDelReq and send SubsDelFail
1669 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1670 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1672 // Xapp: Receive SubsDelResp
1673 xappConn1.RecvSubsDelResp(t, deltrans)
1675 // Wait that subs is cleaned
1676 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1678 xappConn1.TestMsgChanEmpty(t)
1679 xappConn2.TestMsgChanEmpty(t)
1680 e2termConn1.TestMsgChanEmpty(t)
1681 mainCtrl.wait_registry_empty(t, 10)
1683 mainCtrl.VerifyCounterValues(t)
1686 //-----------------------------------------------------------------------------
1687 // TestSubReqAndSubDelOkSameAction
1690 // +-------+ +-------+ +---------+ +---------+
1691 // | xapp2 | | xapp1 | | submgr | | e2term |
1692 // +-------+ +-------+ +---------+ +---------+
1697 // | |------------->| |
1700 // | | |------------->|
1702 // | | |<-------------|
1704 // | |<-------------| |
1707 // |--------------------------->| |
1710 // |<---------------------------| |
1712 // | | SubDelReq 1 | |
1713 // | |------------->| |
1715 // | | SubDelResp 1 | |
1716 // | |<-------------| |
1718 // | SubDelReq 2 | |
1719 // |--------------------------->| |
1721 // | | | SubDelReq 2 |
1722 // | | |------------->|
1724 // | | | SubDelReq 2 |
1725 // | | |------------->|
1727 // | SubDelResp 2 | |
1728 // |<---------------------------| |
1730 //-----------------------------------------------------------------------------
1731 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
1732 CaseBegin("TestSubReqAndSubDelOkSameAction")
1734 // Init counter check
1735 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1736 Counter{cSubReqFromXapp, 2},
1737 Counter{cSubReqToE2, 1},
1738 Counter{cSubRespFromE2, 1},
1739 Counter{cSubRespToXapp, 2},
1740 Counter{cMergedSubscriptions, 1},
1741 Counter{cUnmergedSubscriptions, 1},
1742 Counter{cSubDelReqFromXapp, 2},
1743 Counter{cSubDelReqToE2, 1},
1744 Counter{cSubDelRespFromE2, 1},
1745 Counter{cSubDelRespToXapp, 2},
1749 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1751 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1752 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1753 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1754 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1757 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1759 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1760 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1762 resp, _ := xapp.Subscription.QuerySubscriptions()
1763 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1764 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1765 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
1768 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1769 xappConn1.RecvSubsDelResp(t, deltrans1)
1772 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1773 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1774 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1775 xappConn2.RecvSubsDelResp(t, deltrans2)
1776 //Wait that subs is cleaned
1777 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1779 xappConn1.TestMsgChanEmpty(t)
1780 xappConn2.TestMsgChanEmpty(t)
1781 e2termConn1.TestMsgChanEmpty(t)
1782 mainCtrl.wait_registry_empty(t, 10)
1784 mainCtrl.VerifyCounterValues(t)
1787 //-----------------------------------------------------------------------------
1788 // TestSubReqAndSubDelOkSameActionParallel
1791 // +-------+ +-------+ +---------+ +---------+
1792 // | xapp2 | | xapp1 | | submgr | | e2term |
1793 // +-------+ +-------+ +---------+ +---------+
1798 // | |------------->| |
1801 // | | |------------->|
1803 // |--------------------------->| |
1805 // | | |<-------------|
1807 // | |<-------------| |
1810 // |<---------------------------| |
1812 // | | SubDelReq 1 | |
1813 // | |------------->| |
1815 // | | SubDelResp 1 | |
1816 // | |<-------------| |
1818 // | SubDelReq 2 | |
1819 // |--------------------------->| |
1821 // | | | SubDelReq 2 |
1822 // | | |------------->|
1824 // | | | SubDelReq 2 |
1825 // | | |------------->|
1827 // | SubDelResp 2 | |
1828 // |<---------------------------| |
1830 //-----------------------------------------------------------------------------
1831 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1832 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1835 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1837 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1838 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1841 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1843 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1846 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1847 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1850 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1853 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1854 xappConn1.RecvSubsDelResp(t, deltrans1)
1857 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1858 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1859 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1860 xappConn2.RecvSubsDelResp(t, deltrans2)
1862 //Wait that subs is cleaned
1863 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1865 xappConn1.TestMsgChanEmpty(t)
1866 xappConn2.TestMsgChanEmpty(t)
1867 e2termConn1.TestMsgChanEmpty(t)
1868 mainCtrl.wait_registry_empty(t, 10)
1871 //-----------------------------------------------------------------------------
1872 // TestSubReqAndSubDelNokSameActionParallel
1875 // +-------+ +-------+ +---------+ +---------+
1876 // | xapp2 | | xapp1 | | submgr | | e2term |
1877 // +-------+ +-------+ +---------+ +---------+
1882 // | |------------->| |
1885 // | | |------------->|
1887 // |--------------------------->| |
1889 // | | |<-------------|
1892 // | |<-------------| |
1895 // |<---------------------------| |
1897 //-----------------------------------------------------------------------------
1898 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1899 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1902 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1904 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1906 // E2t: Receive SubsReq (first)
1907 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1910 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1912 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1913 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1914 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1916 // E2t: send SubsFail (first)
1917 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1918 fparams1.Set(crereq1)
1919 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1922 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1924 xappConn2.RecvSubsFail(t, cretrans2)
1926 //Wait that subs is cleaned
1927 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1929 xappConn1.TestMsgChanEmpty(t)
1930 xappConn2.TestMsgChanEmpty(t)
1931 e2termConn1.TestMsgChanEmpty(t)
1932 mainCtrl.wait_registry_empty(t, 10)
1935 //-----------------------------------------------------------------------------
1936 // TestSubReqAndSubDelNoAnswerSameActionParallel
1939 // +-------+ +-------+ +---------+ +---------+
1940 // | xapp2 | | xapp1 | | submgr | | e2term |
1941 // +-------+ +-------+ +---------+ +---------+
1946 // | |------------->| |
1949 // | | |------------->|
1951 // |--------------------------->| |
1954 // | | |------------->|
1957 // | | | SubDelReq |
1958 // | | |------------->|
1960 // | | | SubDelResp |
1961 // | | |<-------------|
1963 //-----------------------------------------------------------------------------
1964 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1965 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1968 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1970 xappConn1.SendSubsReq(t, rparams1, nil)
1972 crereq1, _ := e2termConn1.RecvSubsReq(t)
1975 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1977 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1978 xappConn2.SendSubsReq(t, rparams2, nil)
1979 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1981 //Req1 (retransmitted)
1982 e2termConn1.RecvSubsReq(t)
1984 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1985 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1987 //Wait that subs is cleaned
1988 mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10)
1990 xappConn1.TestMsgChanEmpty(t)
1991 xappConn2.TestMsgChanEmpty(t)
1992 e2termConn1.TestMsgChanEmpty(t)
1993 mainCtrl.wait_registry_empty(t, 15)
1996 //----------------------------- Policy cases ---------------------------------
1997 //-----------------------------------------------------------------------------
1998 // TestSubReqPolicyAndSubDelOk
2001 // +-------+ +---------+ +---------+
2002 // | xapp | | submgr | | e2term |
2003 // +-------+ +---------+ +---------+
2006 // |------------->| |
2009 // | |------------->|
2012 // | |<-------------|
2015 // |<-------------| |
2019 // |------------->| |
2022 // | |------------->|
2025 // | |<-------------|
2028 // |<-------------| |
2030 //-----------------------------------------------------------------------------
2031 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
2032 CaseBegin("TestSubReqAndSubDelOk")
2034 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2036 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
2037 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2039 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2040 e2termConn1.SendSubsResp(t, crereq, cremsg)
2041 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2042 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2043 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2045 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2046 xappConn1.RecvSubsDelResp(t, deltrans)
2048 //Wait that subs is cleaned
2049 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2051 xappConn1.TestMsgChanEmpty(t)
2052 xappConn2.TestMsgChanEmpty(t)
2053 e2termConn1.TestMsgChanEmpty(t)
2054 mainCtrl.wait_registry_empty(t, 10)
2057 //-----------------------------------------------------------------------------
2058 // TestSubReqPolicyChangeAndSubDelOk
2061 // +-------+ +---------+ +---------+
2062 // | xapp | | submgr | | e2term |
2063 // +-------+ +---------+ +---------+
2066 // |------------->| |
2069 // | |------------->|
2072 // | |<-------------|
2075 // |<-------------| |
2078 // |------------->| |
2081 // | |------------->|
2084 // | |<-------------|
2087 // |<-------------| |
2090 // |------------->| |
2093 // | |------------->|
2096 // | |<-------------|
2099 // |<-------------| |
2101 //-----------------------------------------------------------------------------
2103 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
2104 CaseBegin("TestSubReqAndSubDelOk")
2106 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2108 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
2109 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2111 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2112 e2termConn1.SendSubsResp(t, crereq, cremsg)
2113 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2116 rparams1.Req.RequestId.InstanceId = e2SubsId
2117 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
2118 xappConn1.SendSubsReq(t, rparams1, cretrans)
2120 crereq, cremsg = e2termConn1.RecvSubsReq(t)
2121 e2termConn1.SendSubsResp(t, crereq, cremsg)
2122 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2123 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2124 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2126 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2127 xappConn1.RecvSubsDelResp(t, deltrans)
2129 //Wait that subs is cleaned
2130 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2132 xappConn1.TestMsgChanEmpty(t)
2133 xappConn2.TestMsgChanEmpty(t)
2134 e2termConn1.TestMsgChanEmpty(t)
2135 mainCtrl.wait_registry_empty(t, 10)
2138 //-----------------------------------------------------------------------------
2139 // TestSubReqAndSubDelOkTwoE2termParallel
2142 // +-------+ +---------+ +---------+ +---------+
2143 // | xapp | | submgr | | e2term1 | | e2term2 |
2144 // +-------+ +---------+ +---------+ +---------+
2149 // |------------->| | |
2152 // | |------------->| |
2155 // |------------->| | |
2158 // | |---------------------------->|
2161 // | |<-------------| |
2163 // |<-------------| | |
2165 // | |<----------------------------|
2167 // |<-------------| | |
2169 // | [SUBS 1 DELETE] | |
2171 // | [SUBS 2 DELETE] | |
2174 //-----------------------------------------------------------------------------
2175 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
2176 CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
2179 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
2180 xappConn1.SendSubsReq(t, nil, cretrans1)
2181 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2183 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
2184 xappConn1.SendSubsReq(t, nil, cretrans2)
2185 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
2188 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2189 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2192 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
2193 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
2196 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2197 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2198 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2199 xappConn1.RecvSubsDelResp(t, deltrans1)
2200 //Wait that subs is cleaned
2201 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
2204 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
2205 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
2206 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
2207 xappConn1.RecvSubsDelResp(t, deltrans2)
2208 //Wait that subs is cleaned
2209 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2211 xappConn1.TestMsgChanEmpty(t)
2212 xappConn2.TestMsgChanEmpty(t)
2213 e2termConn1.TestMsgChanEmpty(t)
2214 e2termConn2.TestMsgChanEmpty(t)
2215 mainCtrl.wait_registry_empty(t, 10)
2218 //-----------------------------------------------------------------------------
2219 // TestSubReqInsertAndSubDelOk
2222 // +-------+ +---------+ +---------+
2223 // | xapp | | submgr | | e2term |
2224 // +-------+ +---------+ +---------+
2227 // |------------->| |
2230 // | |------------->|
2233 // | |<-------------|
2236 // |<-------------| |
2240 // |------------->| |
2243 // | |------------->|
2246 // | |<-------------|
2249 // |<-------------| |
2251 //-----------------------------------------------------------------------------
2252 func TestSubReqInsertAndSubDelOk(t *testing.T) {
2253 CaseBegin("TestInsertSubReqAndSubDelOk")
2255 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2257 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeInsert
2258 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2260 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2261 e2termConn1.SendSubsResp(t, crereq, cremsg)
2262 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2263 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2264 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2266 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2267 xappConn1.RecvSubsDelResp(t, deltrans)
2269 //Wait that subs is cleaned
2270 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2272 xappConn1.TestMsgChanEmpty(t)
2273 xappConn2.TestMsgChanEmpty(t)
2274 e2termConn1.TestMsgChanEmpty(t)
2275 mainCtrl.wait_registry_empty(t, 10)
2278 //-----------------------------------------------------------------------------
2279 // TestSubReqRetransmissionWithSameSubIdDiffXid
2281 // This case simulates case where xApp restarts and starts sending same
2282 // subscription requests which have already subscribed successfully
2285 // +-------+ +---------+ +---------+
2286 // | xapp | | submgr | | e2term |
2287 // +-------+ +---------+ +---------+
2290 // |------------->| |
2293 // | |------------->|
2296 // | |<-------------|
2299 // |<-------------| |
2301 // | xApp restart | |
2304 // | (retrans with same xApp generated subid but diff xid)
2305 // |------------->| |
2308 // |<-------------| |
2310 // | [SUBS DELETE] |
2313 //-----------------------------------------------------------------------------
2314 func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) {
2315 CaseBegin("TestSubReqRetransmissionWithSameSubIdDiffXid")
2318 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2319 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2320 e2termConn1.SendSubsResp(t, crereq, cremsg)
2321 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2323 // xApp restart here
2324 // --> artificial delay
2325 <-time.After(1 * time.Second)
2328 cretrans = xappConn1.SendSubsReq(t, nil, nil) //Retransmitted SubReq
2329 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2332 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2333 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2334 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2335 xappConn1.RecvSubsDelResp(t, deltrans)
2337 //Wait that subs is cleaned
2338 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2340 xappConn1.TestMsgChanEmpty(t)
2341 xappConn2.TestMsgChanEmpty(t)
2342 e2termConn1.TestMsgChanEmpty(t)
2343 mainCtrl.wait_registry_empty(t, 10)
2346 //-----------------------------------------------------------------------------
2347 // TestSubReqNokAndSubDelOkWithRestartInMiddle
2350 // +-------+ +---------+ +---------+
2351 // | xapp | | submgr | | e2term |
2352 // +-------+ +---------+ +---------+
2355 // |------------->| |
2358 // | |------------->|
2363 // | Submgr restart |
2367 // | |------------->|
2370 // | |<-------------|
2373 //-----------------------------------------------------------------------------
2375 func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
2376 CaseBegin("TestSubReqNokAndSubDelOkWithRestartInMiddle")
2378 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
2379 xappConn1.SendSubsReq(t, nil, nil)
2380 e2termConn1.RecvSubsReq(t)
2381 mainCtrl.SetResetTestFlag(t, false)
2383 resp, _ := xapp.Subscription.QuerySubscriptions()
2384 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2385 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2386 e2SubsId := uint32(resp[0].SubscriptionID)
2387 t.Logf("e2SubsId = %v", e2SubsId)
2389 mainCtrl.SimulateRestart(t)
2390 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2392 // Submgr send delete for uncompleted subscription
2393 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2394 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2396 // Wait that subs is cleaned
2397 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2399 xappConn1.TestMsgChanEmpty(t)
2400 xappConn2.TestMsgChanEmpty(t)
2401 e2termConn1.TestMsgChanEmpty(t)
2402 mainCtrl.wait_registry_empty(t, 10)
2405 //-----------------------------------------------------------------------------
2406 // TestSubReqAndSubDelOkWithRestartInMiddle
2409 // +-------+ +---------+ +---------+
2410 // | xapp | | submgr | | e2term |
2411 // +-------+ +---------+ +---------+
2414 // |------------->| |
2417 // | |------------->|
2420 // | |<-------------|
2423 // |<-------------| |
2426 // | Submgr restart |
2429 // |------------->| |
2432 // | |------------->|
2435 // | |<-------------|
2438 // |<-------------| |
2440 //-----------------------------------------------------------------------------
2442 func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
2443 CaseBegin("TestSubReqAndSubDelOkWithRestartInMiddle")
2445 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2446 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2447 e2termConn1.SendSubsResp(t, crereq, cremsg)
2448 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2450 // Check subscription
2451 resp, _ := xapp.Subscription.QuerySubscriptions()
2452 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2453 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2454 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2456 mainCtrl.SimulateRestart(t)
2457 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2459 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
2460 // That needs to be completed before successful subscription query is possible
2461 <-time.After(time.Second * 1)
2463 // Check that subscription is restored correctly after restart
2464 resp, _ = xapp.Subscription.QuerySubscriptions()
2465 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2466 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2467 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2469 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2470 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2471 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2472 xappConn1.RecvSubsDelResp(t, deltrans)
2474 //Wait that subs is cleaned
2475 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2477 xappConn1.TestMsgChanEmpty(t)
2478 xappConn2.TestMsgChanEmpty(t)
2479 e2termConn1.TestMsgChanEmpty(t)
2480 mainCtrl.wait_registry_empty(t, 10)
2483 //-----------------------------------------------------------------------------
2484 // TestSubReqAndSubDelOkSameActionWithRestartsInMiddle
2487 // +-------+ +-------+ +---------+ +---------+
2488 // | xapp2 | | xapp1 | | submgr | | e2term |
2489 // +-------+ +-------+ +---------+ +---------+
2494 // | |------------->| |
2497 // | | |------------->|
2499 // | | |<-------------|
2501 // | |<-------------| |
2504 // | submgr restart |
2509 // |--------------------------->| |
2512 // |<---------------------------| |
2514 // | | SubDelReq 1 | |
2515 // | |------------->| |
2517 // | | SubDelResp 1 | |
2518 // | |<-------------| |
2522 // | submgr restart |
2525 // | SubDelReq 2 | |
2526 // |--------------------------->| |
2528 // | | | SubDelReq 2 |
2529 // | | |------------->|
2531 // | | | SubDelReq 2 |
2532 // | | |------------->|
2534 // | SubDelResp 2 | |
2535 // |<---------------------------| |
2537 //-----------------------------------------------------------------------------
2539 func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
2540 CaseBegin("TestSubReqAndSubDelOkSameActionWithRestartsInMiddle")
2543 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2545 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2546 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2547 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2548 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2551 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2553 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2554 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
2556 // Check subscription
2557 resp, _ := xapp.Subscription.QuerySubscriptions()
2558 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2559 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2560 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2562 mainCtrl.SimulateRestart(t)
2563 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2565 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
2566 // That needs to be completed before successful subscription query is possible
2567 <-time.After(time.Second * 1)
2569 // Check that subscription is restored correctly after restart
2570 resp, _ = xapp.Subscription.QuerySubscriptions()
2571 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2572 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2573 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2576 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2577 xapp.Logger.Debug("xappConn1.RecvSubsDelResp")
2578 xappConn1.RecvSubsDelResp(t, deltrans1)
2579 xapp.Logger.Debug("xappConn1.RecvSubsDelResp received")
2581 mainCtrl.SimulateRestart(t)
2582 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2584 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
2585 // Submgr need be ready before successful subscription deletion is possible
2586 <-time.After(time.Second * 1)
2589 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
2590 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2592 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2593 xappConn2.RecvSubsDelResp(t, deltrans2)
2595 //Wait that subs is cleaned
2596 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2598 xappConn1.TestMsgChanEmpty(t)
2599 xappConn2.TestMsgChanEmpty(t)
2600 e2termConn1.TestMsgChanEmpty(t)
2601 mainCtrl.wait_registry_empty(t, 10)
2604 //*****************************************************************************
2605 // REST interface test cases
2606 //*****************************************************************************
2608 //-----------------------------------------------------------------------------
2609 // Test debug GET and POST requests
2612 // +-------+ +---------+
2613 // | user | | submgr |
2614 // +-------+ +---------+
2621 func TestGetSubscriptions(t *testing.T) {
2623 mainCtrl.sendGetRequest(t, "localhost:8088", "/ric/v1/subscriptions")
2626 func TestGetSymptomData(t *testing.T) {
2628 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/symptomdata")
2631 func TestPostdeleteSubId(t *testing.T) {
2633 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/deletesubid=1")
2636 func TestPostEmptyDb(t *testing.T) {
2638 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/emptydb")
2641 func TestGetRestSubscriptions(t *testing.T) {
2643 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/restsubscriptions")
2646 //-----------------------------------------------------------------------------
2647 // TestRESTSubReqAndRouteNok
2650 // +-------+ +---------+ +---------+
2651 // | xapp | | submgr | | rtmgr |
2652 // +-------+ +---------+ +---------+
2655 // |---------------->| |
2657 // | RESTSubResp | |
2658 // |<----------------| |
2659 // | | RouteCreate |
2660 // | |------------->|
2662 // | | RouteCreate |
2664 // | |(Bad request) |
2665 // | |<-------------|
2667 // |<----------------| |
2669 // | [SUBS INT DELETE] |
2671 // | RESTSubDelReq | |
2672 // |---------------->| |
2673 // | RESTSubDelResp | |
2674 // |<----------------| |
2676 //-----------------------------------------------------------------------------
2677 func TestRESTSubReqAndRouteNok(t *testing.T) {
2678 CaseBegin("TestRESTSubReqAndRouteNok")
2680 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2681 Counter{cRestSubReqFromXapp, 1},
2682 Counter{cRestSubRespToXapp, 1},
2683 Counter{cRouteCreateFail, 1},
2684 Counter{cRestSubFailNotifToXapp, 1},
2685 Counter{cRestSubDelReqFromXapp, 1},
2686 Counter{cRestSubDelRespToXapp, 1},
2689 const subReqCount int = 1
2691 // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
2692 waiter := rtmgrHttp.AllocNextSleep(50, false)
2693 newSubsId := mainCtrl.get_registry_next_subid(t)
2696 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2697 restSubId := xappConn1.SendRESTSubsReq(t, params)
2698 xappConn1.ExpectRESTNotificationNok(t, restSubId, "failAll")
2699 waiter.WaitResult(t)
2701 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2702 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
2705 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2707 // Wait that subs is cleaned
2708 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2709 waitSubsCleanup(t, e2SubsId, 10)
2710 mainCtrl.VerifyCounterValues(t)
2711 mainCtrl.VerifyAllClean(t)
2714 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
2715 CaseBegin("TestSubReqAndRouteUpdateNok")
2717 //Init counter check
2718 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2719 Counter{cRestSubReqFromXapp, 2},
2720 Counter{cRestSubRespToXapp, 2},
2721 Counter{cSubReqToE2, 1},
2722 Counter{cSubRespFromE2, 1},
2723 Counter{cRestSubNotifToXapp, 1},
2724 Counter{cRestSubFailNotifToXapp, 1},
2725 Counter{cRouteCreateUpdateFail, 1},
2726 Counter{cRestSubDelReqFromXapp, 2},
2727 Counter{cSubDelReqToE2, 1},
2728 Counter{cSubDelRespFromE2, 1},
2729 Counter{cRestSubDelRespToXapp, 2},
2732 var params *teststube2ap.RESTSubsReqParams = nil
2735 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2737 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2739 // xapp2 ROUTE creation shall fail with 400 from rtmgr -> submgr
2740 waiter := rtmgrHttp.AllocNextEvent(false)
2741 newSubsId := mainCtrl.get_registry_next_subid(t)
2742 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
2743 params.SetMeid("RAN_NAME_1")
2744 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2745 xapp.Logger.Debug("Send REST subscriber request for second subscriber : %v", restSubId2)
2746 xappConn2.ExpectRESTNotificationNok(t, restSubId2, "allFail")
2747 waiter.WaitResult(t)
2748 xappConn2.WaitRESTNotification(t, restSubId2)
2750 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2752 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2753 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
2755 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2756 //Wait that subs is cleaned
2757 waitSubsCleanup(t, e2SubsId, 10)
2759 mainCtrl.VerifyCounterValues(t)
2760 mainCtrl.VerifyAllClean(t)
2763 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
2764 CaseBegin("TestRESTSubDelReqAndRouteDeleteNok")
2766 // Init counter check
2767 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2768 Counter{cRestSubReqFromXapp, 1},
2769 Counter{cRestSubRespToXapp, 1},
2770 Counter{cSubReqToE2, 1},
2771 Counter{cSubRespFromE2, 1},
2772 Counter{cRestSubNotifToXapp, 1},
2773 Counter{cRestSubDelReqFromXapp, 1},
2774 Counter{cRouteDeleteFail, 1},
2775 Counter{cSubDelReqToE2, 1},
2776 Counter{cSubDelRespFromE2, 1},
2777 Counter{cRestSubDelRespToXapp, 1},
2780 var params *teststube2ap.RESTSubsReqParams = nil
2783 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2785 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2787 waiter := rtmgrHttp.AllocNextEvent(false)
2788 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2789 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2790 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2791 waiter.WaitResult(t)
2793 waitSubsCleanup(t, e2SubsId, 10)
2794 mainCtrl.VerifyCounterValues(t)
2795 mainCtrl.VerifyAllClean(t)
2798 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
2799 CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok")
2801 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2802 Counter{cRestSubReqFromXapp, 2},
2803 Counter{cMergedSubscriptions, 1},
2804 Counter{cRestSubRespToXapp, 2},
2805 Counter{cSubReqToE2, 1},
2806 Counter{cSubRespFromE2, 1},
2807 Counter{cRestSubNotifToXapp, 2},
2808 Counter{cRestSubDelReqFromXapp, 2},
2809 Counter{cRouteDeleteUpdateFail, 1},
2810 Counter{cSubDelReqToE2, 1},
2811 Counter{cSubDelRespFromE2, 1},
2812 Counter{cRestSubDelRespToXapp, 2},
2813 Counter{cUnmergedSubscriptions, 1},
2816 var params *teststube2ap.RESTSubsReqParams = nil
2819 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2821 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2822 restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1")
2824 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
2826 //Del1, this shall fail on rtmgr side
2827 waiter := rtmgrHttp.AllocNextEvent(false)
2828 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2829 waiter.WaitResult(t)
2831 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"})
2834 deleteXapp2Subscription(t, &restSubId2)
2836 waitSubsCleanup(t, e2SubsId2, 10)
2837 mainCtrl.VerifyCounterValues(t)
2838 mainCtrl.VerifyAllClean(t)
2841 //-----------------------------------------------------------------------------
2842 // TestRESTSubReqRetransmission
2845 // +-------+ +---------+ +---------+
2846 // | xapp | | submgr | | e2term |
2847 // +-------+ +---------+ +---------+
2849 // | RESTSubReq1 | |
2850 // |---------------->| |
2852 // | RESTSubResp | |
2853 // |<----------------| |
2855 // | |------------->|
2857 // | RESTSubReq2 | |
2859 // |---------------->| |
2860 // | RESTSubResp(201)| |
2861 // |<----------------| |
2864 // | |<-------------|
2866 // |<----------------| |
2868 // | [SUBS DELETE] |
2871 //-----------------------------------------------------------------------------
2873 func TestRESTSubReqRetransmission(t *testing.T) {
2874 CaseBegin("TestRESTSubReqRetransmission")
2876 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2877 Counter{cRestSubReqFromXapp, 2},
2878 Counter{cRestSubRespToXapp, 2},
2879 Counter{cSubReqToE2, 1},
2880 Counter{cSubRespFromE2, 1},
2881 Counter{cRestSubNotifToXapp, 1},
2882 Counter{cRestSubDelReqFromXapp, 1},
2883 Counter{cSubDelReqToE2, 1},
2884 Counter{cSubDelRespFromE2, 1},
2885 Counter{cRestSubDelRespToXapp, 1},
2887 // Retry/duplicate will get the same way as the first request.
2888 // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
2889 // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
2892 const subReqCount int = 1
2894 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2895 restSubId := xappConn1.SendRESTSubsReq(t, params)
2897 xappConn1.SendRESTSubsReq(t, params)
2898 <-time.After(time.Second * 1)
2900 xappConn1.WaitListedRestNotifications(t, []string{restSubId})
2902 // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
2903 // the order is not significant here.
2904 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2905 e2termConn1.SendSubsResp(t, crereq, cremsg)
2907 e2SubsId := <-xappConn1.ListedRESTNotifications
2909 xapp.Logger.Debug("TEST: XAPP notification received e2SubsId=%v", e2SubsId)
2912 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2913 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2914 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2916 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsId.E2SubsId}, 10)
2918 mainCtrl.VerifyCounterValues(t)
2919 mainCtrl.VerifyAllClean(t)
2922 //-----------------------------------------------------------------------------
2924 // +-------+ +---------+ +---------+ +---------+
2925 // | xapp | | submgr | | e2term | | rtmgr |
2926 // +-------+ +---------+ +---------+ +---------+
2928 // | RESTSubReq | | |
2929 // |---------------->| | |
2930 // | RESTSubResp | | |
2931 // |<----------------| | |
2932 // | | RouteCreate | |
2933 // | |--------------------------->|
2934 // | | RouteResponse| |
2935 // | |<---------------------------| // The order of these events may vary
2937 // | |------------->| | // The order of these events may vary
2939 // | |<-------------| |
2940 // | RESTNotif1 | | |
2941 // |<----------------| | |
2942 // | RESTSubReq | | |
2943 // | [RETRANS1] | | |
2944 // |---------------->| | |
2945 // | RESTNotif1 | | |
2946 // |<----------------| | |
2947 // | RESTSubReq | | |
2948 // | [RETRANS2] | | |
2949 // |---------------->| | |
2950 // | RESTNotif1 | | |
2951 // |<----------------| | |
2952 // | RESTSubDelReq | | |
2953 // |---------------->| | |
2954 // | | SubDelReq | |
2955 // | |------------->| |
2956 // | RESTSubDelResp| | |
2957 // |<----------------| | |
2958 // | | SubDelResp | |
2959 // | |<-------------| |
2962 //-----------------------------------------------------------------------------
2964 func TestRESTSubReqRetransmissionV2(t *testing.T) {
2965 CaseBegin("TestRESTSubReqRetransmissionV2")
2967 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2968 Counter{cRestSubReqFromXapp, 3},
2969 Counter{cDuplicateE2SubReq, 2},
2970 Counter{cRestSubRespToXapp, 3},
2971 Counter{cSubReqToE2, 1},
2972 Counter{cSubRespFromE2, 1},
2973 Counter{cRestSubNotifToXapp, 3},
2974 Counter{cRestSubDelReqFromXapp, 1},
2975 Counter{cSubDelReqToE2, 1},
2976 Counter{cSubDelRespFromE2, 1},
2977 Counter{cRestSubDelRespToXapp, 1},
2980 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2982 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2984 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2986 mainCtrl.WaitOngoingRequestMapEmpty()
2989 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
2991 assert.Equal(t, restSubId_resend, restSubId)
2993 mainCtrl.WaitOngoingRequestMapEmpty()
2996 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
2998 assert.Equal(t, restSubId_resend2, restSubId)
3000 mainCtrl.WaitOngoingRequestMapEmpty()
3002 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3004 waitSubsCleanup(t, e2SubsId, 10)
3005 mainCtrl.VerifyCounterValues(t)
3006 mainCtrl.VerifyAllClean(t)
3009 //-----------------------------------------------------------------------------
3011 // +-------+ +---------+ +---------+ +---------+
3012 // | xapp | | submgr | | e2term | | rtmgr |
3013 // +-------+ +---------+ +---------+ +---------+
3015 // | RESTSubReq | | |
3016 // |---------------->| | |
3017 // | RESTSubResp | | |
3018 // |<----------------| | |
3019 // | | RouteCreate | |
3020 // | |--------------------------->|
3021 // | | RouteResponse| |
3022 // | |<---------------------------| // The order of these events may vary
3024 // | |------------->| | // The order of these events may vary
3026 // | |<-------------| |
3027 // | RESTNotif1 | | |
3028 // |<----------------| | |
3029 // | RESTSubReq | | |
3030 // | [RETRANS, with RESTsubsId] | |
3031 // |---------------->| | |
3032 // | RESTNotif1 | | |
3033 // |<----------------| | |
3034 // | RESTSubReq | | |
3035 // | [RETRANS, without RESTsubsId] | |
3036 // |---------------->| | |
3037 // | RESTNotif1 | | |
3038 // |<----------------| | |
3039 // | RESTSubDelReq | | |
3040 // |---------------->| | |
3041 // | | SubDelReq | |
3042 // | |------------->| |
3043 // | RESTSubDelResp| | |
3044 // |<----------------| | |
3045 // | | SubDelResp | |
3046 // | |<-------------| |
3049 //-----------------------------------------------------------------------------
3050 func TestRESTSubReqRetransmissionV3(t *testing.T) {
3051 CaseBegin("TestRESTSubReqRetransmissionV3")
3053 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3054 Counter{cRestSubReqFromXapp, 3},
3055 Counter{cDuplicateE2SubReq, 2},
3056 Counter{cRestSubRespToXapp, 3},
3057 Counter{cSubReqToE2, 1},
3058 Counter{cSubRespFromE2, 1},
3059 Counter{cRestSubNotifToXapp, 3},
3060 Counter{cRestSubDelReqFromXapp, 1},
3061 Counter{cSubDelReqToE2, 1},
3062 Counter{cSubDelRespFromE2, 1},
3063 Counter{cRestSubDelRespToXapp, 1},
3066 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3068 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3070 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3072 mainCtrl.WaitOngoingRequestMapEmpty()
3074 //1.st resend with subscription ID
3075 params.SetSubscriptionID(&restSubId)
3076 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
3078 assert.Equal(t, restSubId_resend, restSubId)
3080 mainCtrl.WaitOngoingRequestMapEmpty()
3082 //2.nd resend without subscription ID (faking app restart)
3083 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3084 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3086 assert.Equal(t, restSubId_resend2, restSubId)
3088 mainCtrl.WaitOngoingRequestMapEmpty()
3090 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3092 waitSubsCleanup(t, e2SubsId, 10)
3093 mainCtrl.VerifyCounterValues(t)
3094 mainCtrl.VerifyAllClean(t)
3097 //-----------------------------------------------------------------------------
3099 // +-------+ +---------+ +---------+ +---------+
3100 // | xapp | | submgr | | e2term | | rtmgr |
3101 // +-------+ +---------+ +---------+ +---------+
3103 // | RESTSubReq | | |
3104 // |---------------->| | |
3105 // | RESTSubResp | | |
3106 // |<----------------| | |
3107 // | | RouteCreate | |
3108 // | |--------------------------->|
3109 // | | RouteResponse| |
3110 // | |<---------------------------|
3112 // | |------------->| |
3114 // | |<-------------| |
3115 // | RESTNotif1 | | |
3116 // |<----------------| | |
3117 // | RESTSubReq | | |
3118 // | [with RestSUbsId + one additional e2 subDetail]
3119 // |---------------->| | |
3120 // | RESTNotif1 | | |
3121 // | [for initial e2 subDetail] | |
3122 // |<----------------| | |
3123 // | | RouteCreate | |
3124 // | |--------------------------->|
3125 // | | RouteResponse| |
3126 // | |<---------------------------|
3128 // | |------------->| |
3130 // | |<-------------| |
3131 // | RESTNotif1 | | |
3132 // |<----------------| | |
3133 // | RESTSubReq | | |
3134 // | [with RESTsubsId initial request] |
3135 // |---------------->| | |
3136 // | RESTNotif1 | | |
3137 // |<----------------| | |
3138 // | RESTSubDelReq | | |
3139 // |---------------->| | |
3140 // | RESTSubDelResp| | |
3141 // |<----------------| | |
3142 // | | SubDelReq | |
3143 // | |------------->| |
3144 // | | SubDelResp | |
3145 // | |<-------------| |
3146 // | | SubDelReq | |
3147 // | |------------->| |
3148 // | | SubDelResp | |
3149 // | |<-------------| |
3152 //-----------------------------------------------------------------------------
3154 func TestRESTSubReqRetransmissionV4(t *testing.T) {
3155 CaseBegin("TestRESTSubReqRetransmissionV4")
3157 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3158 Counter{cRestSubReqFromXapp, 3},
3159 Counter{cDuplicateE2SubReq, 2},
3160 Counter{cRestSubRespToXapp, 3},
3161 Counter{cSubReqToE2, 2},
3162 Counter{cSubRespFromE2, 2},
3163 Counter{cRestSubNotifToXapp, 4},
3164 Counter{cRestSubDelReqFromXapp, 1},
3165 Counter{cSubDelReqToE2, 2},
3166 Counter{cSubDelRespFromE2, 2},
3167 Counter{cRestSubDelRespToXapp, 1},
3170 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3172 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3174 mainCtrl.WaitOngoingRequestMapEmpty()
3176 // Send modified requst, this time with e2 subscriptions.
3177 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3178 params2.SetSubscriptionID(&restSubId)
3180 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3181 xappConn1.ExpectAnyNotification(t)
3182 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3183 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3184 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3185 assert.Equal(t, e2SubsId, e2SubsId1)
3187 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3189 xappConn1.DecrementRequestCount()
3190 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3191 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3192 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3193 assert.NotEqual(t, e2SubsId2, 0)
3195 mainCtrl.WaitOngoingRequestMapEmpty()
3197 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3198 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3199 params.SetSubscriptionID(&restSubId)
3200 xappConn1.ExpectAnyNotification(t)
3201 // Resend the original request again with only one e2 subscription (detail), this time with restsubsid
3202 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3203 assert.Equal(t, restSubId_resend, restSubId_resend2)
3205 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3206 assert.Equal(t, e2SubsId, e2SubsId1)
3208 mainCtrl.WaitOngoingRequestMapEmpty()
3210 // Delete both e2 subscriptions
3211 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3212 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3213 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3215 waitSubsCleanup(t, e2SubsId, 10)
3216 mainCtrl.VerifyCounterValues(t)
3217 mainCtrl.VerifyAllClean(t)
3220 //-----------------------------------------------------------------------------
3222 // +-------+ +---------+ +---------+ +---------+
3223 // | xapp | | submgr | | e2term | | rtmgr |
3224 // +-------+ +---------+ +---------+ +---------+
3226 // | RESTSubReq | | |
3227 // |---------------->| | |
3228 // | RESTSubResp | | |
3229 // |<----------------| | |
3230 // | | RouteCreate | |
3231 // | |--------------------------->|
3232 // | | RouteResponse| |
3233 // | |<---------------------------|
3235 // | |------------->| |
3237 // | |<-------------| |
3238 // | RESTNotif1 | | |
3239 // |<----------------| | |
3240 // | RESTSubReq | | |
3241 // | [with RestSUbsId + one additional e2 subDetail]
3242 // |---------------->| | |
3243 // | RESTNotif1 | | |
3244 // | [for initial e2 subDetail] | |
3245 // |<----------------| | |
3246 // | | RouteCreate | |
3247 // | |--------------------------->|
3248 // | | RouteResponse| |
3249 // | |<---------------------------|
3251 // | |------------->| |
3253 // | |<-------------| |
3254 // | RESTNotif1 | | |
3255 // |<----------------| | |
3256 // | RESTSubReq | | |
3257 // | [without RESTsubsId initial request] |
3258 // |---------------->| | |
3259 // | RESTNotif1 | | |
3260 // |<----------------| | |
3261 // | RESTSubDelReq | | |
3262 // |---------------->| | |
3263 // | RESTSubDelResp| | |
3264 // |<----------------| | |
3265 // | | SubDelReq | |
3266 // | |------------->| |
3267 // | | SubDelResp | |
3268 // | |<-------------| |
3269 // | | SubDelReq | |
3270 // | |------------->| |
3271 // | | SubDelResp | |
3272 // | |<-------------| |
3275 //-----------------------------------------------------------------------------
3277 func TestRESTSubReqRetransmissionV5(t *testing.T) {
3278 CaseBegin("TestRESTSubReqRetransmissionV5")
3280 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3281 Counter{cRestSubReqFromXapp, 3},
3282 Counter{cDuplicateE2SubReq, 2},
3283 Counter{cRestSubRespToXapp, 3},
3284 Counter{cSubReqToE2, 2},
3285 Counter{cSubRespFromE2, 2},
3286 Counter{cRestSubNotifToXapp, 4},
3287 Counter{cRestSubDelReqFromXapp, 1},
3288 Counter{cSubDelReqToE2, 2},
3289 Counter{cSubDelRespFromE2, 2},
3290 Counter{cRestSubDelRespToXapp, 1},
3293 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3295 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3297 mainCtrl.WaitOngoingRequestMapEmpty()
3299 // Send modified requst, this time with e2 subscriptions.
3300 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3301 params2.SetSubscriptionID(&restSubId)
3303 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3304 xappConn1.ExpectAnyNotification(t)
3305 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3306 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3308 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3309 assert.Equal(t, e2SubsId, e2SubsId1)
3310 // The first E2 subscription returns immediately, manually decrement expected request count for the remaining request handling
3311 xappConn1.DecrementRequestCount()
3313 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3315 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3316 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3317 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3318 assert.NotEqual(t, e2SubsId2, 0)
3320 mainCtrl.WaitOngoingRequestMapEmpty()
3322 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3323 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3324 xappConn1.ExpectAnyNotification(t)
3325 // Resend the original request again with only one e2 subscription (detail), WITHOUT restsubsid
3326 // md5sum shall find the original request
3327 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3328 assert.Equal(t, restSubId_resend, restSubId_resend2)
3330 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3331 assert.Equal(t, e2SubsId, e2SubsId1)
3333 mainCtrl.WaitOngoingRequestMapEmpty()
3335 // Delete both e2 subscriptions
3336 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3337 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3338 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3340 waitSubsCleanup(t, e2SubsId, 10)
3341 mainCtrl.VerifyCounterValues(t)
3342 mainCtrl.VerifyAllClean(t)
3345 //-----------------------------------------------------------------------------
3347 // +-------+ +---------+ +---------+ +---------+
3348 // | xapp | | submgr | | e2term | | rtmgr |
3349 // +-------+ +---------+ +---------+ +---------+
3351 // | RESTSubReq | | |
3352 // |---------------->| | |
3353 // | RESTSubResp | | |
3354 // |<----------------| | |
3355 // | | RouteCreate | |
3356 // | |--------------------------->|
3357 // | | RouteResponse| |
3358 // | |<---------------------------|
3360 // | |------------->| |
3362 // | |<-------------| |
3363 // | RESTNotif1 | | |
3364 // |<----------------| | |
3365 // | RESTSubReq | | |
3366 // | [with RestSUbsId + one additional e2 subDetail]
3367 // |---------------->| | |
3368 // | RESTNotif1 | | |
3369 // | [for initial e2 subDetail] | |
3370 // |<----------------| | |
3371 // | | RouteCreate | |
3372 // | |--------------------------->|
3373 // | | RouteResponse| |
3374 // | |<---------------------------|
3376 // | |------------->| |
3378 // | |<-------------| |
3379 // | RESTNotif1 | | |
3380 // |<----------------| | |
3381 // | RESTSubDelReq | | |
3382 // |---------------->| | |
3383 // | RESTSubDelResp| | |
3384 // |<----------------| | |
3385 // | | SubDelReq | |
3386 // | |------------->| |
3387 // | | SubDelResp | |
3388 // | |<-------------| |
3389 // | | SubDelReq | |
3390 // | |------------->| |
3391 // | | SubDelResp | |
3392 // | |<-------------| |
3393 // | RESTSubReq | | |
3394 // | [with RESTsubsId initial request] |
3395 // |---------------->| | |
3396 // | RESTSubResp | | |
3397 // |<----------------| | |
3398 // | | RouteCreate | |
3399 // | |--------------------------->|
3400 // | | RouteResponse| |
3401 // | |<---------------------------|
3403 // | |------------->| |
3405 // | |<-------------| |
3406 // | RESTNotif1 | | |
3407 // |<----------------| | |
3410 //-----------------------------------------------------------------------------
3411 func TestRESTSubReqRetransmissionV6(t *testing.T) {
3412 CaseBegin("TestRESTSubReqRetransmissionV6")
3414 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3415 Counter{cRestSubReqFromXapp, 3},
3416 Counter{cDuplicateE2SubReq, 1},
3417 Counter{cRestSubRespToXapp, 3},
3418 Counter{cSubReqToE2, 3},
3419 Counter{cSubRespFromE2, 3},
3420 Counter{cRestSubNotifToXapp, 4},
3421 Counter{cRestSubDelReqFromXapp, 2},
3422 Counter{cSubDelReqToE2, 3},
3423 Counter{cSubDelRespFromE2, 3},
3424 Counter{cRestSubDelRespToXapp, 2},
3427 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3429 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3431 mainCtrl.WaitOngoingRequestMapEmpty()
3433 // Send modified requst, this time with e2 subscriptions.
3434 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3435 params2.SetSubscriptionID(&restSubId)
3437 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3438 xappConn1.ExpectAnyNotification(t)
3439 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3440 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3442 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3443 assert.Equal(t, e2SubsId, e2SubsId1)
3445 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3447 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3448 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3449 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3450 assert.NotEqual(t, e2SubsId2, 0)
3452 mainCtrl.WaitOngoingRequestMapEmpty()
3454 // Delete both e2 subscriptions
3455 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3456 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3457 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3459 waitSubsCleanup(t, e2SubsId, 10)
3461 // Resend the original request, we shall find it's previous md5sum/restsubs
3462 // but the restsubscription has been already removed. This shall trigger a
3464 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
3466 mainCtrl.WaitOngoingRequestMapEmpty()
3468 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3470 waitSubsCleanup(t, e2SubsId, 10)
3471 mainCtrl.VerifyCounterValues(t)
3472 mainCtrl.VerifyAllClean(t)
3475 func TestRESTSubDelReqRetransmission(t *testing.T) {
3476 CaseBegin("TestRESTSubDelReqRetransmission")
3478 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3479 Counter{cRestSubReqFromXapp, 1},
3480 Counter{cRestSubRespToXapp, 1},
3481 Counter{cSubReqToE2, 1},
3482 Counter{cSubRespFromE2, 1},
3483 Counter{cRestSubNotifToXapp, 1},
3484 Counter{cRestSubDelReqFromXapp, 2},
3485 Counter{cSubDelReqToE2, 1},
3486 Counter{cSubDelRespFromE2, 1},
3487 Counter{cRestSubDelRespToXapp, 2},
3490 var params *teststube2ap.RESTSubsReqParams = nil
3493 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3495 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3498 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3499 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3501 seqBef := mainCtrl.get_msgcounter(t)
3502 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3503 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
3505 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3507 waitSubsCleanup(t, e2SubsId, 10)
3508 mainCtrl.VerifyCounterValues(t)
3509 mainCtrl.VerifyAllClean(t)
3512 //-----------------------------------------------------------------------------
3513 // TestRESTSubReqDelReq
3516 // +-------+ +---------+ +---------+
3517 // | xapp | | submgr | | e2term |
3518 // +-------+ +---------+ +---------+
3521 // |---------------->| |
3523 // | RESTSubResp | |
3524 // |<----------------| |
3526 // | |------------->|
3527 // | RESTSubDelReq | |
3528 // |---------------->| |
3529 // | RESTSubDelResp | |
3531 // |<----------------| |
3533 // | |<-------------|
3535 // |<----------------| |
3537 // | [SUBS DELETE] |
3540 //-----------------------------------------------------------------------------
3541 func TestRESTSubReqDelReq(t *testing.T) {
3542 CaseBegin("TestRESTSubReqDelReq")
3544 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3545 Counter{cRestSubReqFromXapp, 1},
3546 Counter{cRestSubRespToXapp, 1},
3547 Counter{cSubReqToE2, 1},
3548 Counter{cSubRespFromE2, 1},
3549 Counter{cRestSubNotifToXapp, 1},
3550 Counter{cRestSubDelReqFromXapp, 2},
3551 Counter{cRestSubDelFailToXapp, 1},
3552 Counter{cSubDelReqToE2, 1},
3553 Counter{cSubDelRespFromE2, 1},
3554 Counter{cRestSubDelRespToXapp, 1},
3557 const subReqCount int = 1
3560 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3561 restSubId := xappConn1.SendRESTSubsReq(t, params)
3563 // Del. This will fail as processing of the subscription
3564 // is still ongoing in submgr. Deletion is not allowed before
3565 // subscription creation has been completed.
3566 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3567 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3568 xappConn1.ExpectRESTNotification(t, restSubId)
3569 e2termConn1.SendSubsResp(t, crereq, cremsg)
3570 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3573 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3575 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3576 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3578 // Wait that subs is cleaned
3579 waitSubsCleanup(t, e2SubsId, 10)
3580 mainCtrl.VerifyCounterValues(t)
3581 mainCtrl.VerifyAllClean(t)
3584 func TestRESTSubDelReqCollision(t *testing.T) {
3585 CaseBegin("TestRESTSubDelReqCollision - not relevant for REST API")
3588 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
3589 CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel")
3591 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3592 Counter{cRestSubReqFromXapp, 2},
3593 Counter{cRestSubRespToXapp, 2},
3594 Counter{cSubReqToE2, 2},
3595 Counter{cSubRespFromE2, 2},
3596 Counter{cRestSubNotifToXapp, 2},
3597 Counter{cRestSubDelReqFromXapp, 2},
3598 Counter{cSubDelReqToE2, 2},
3599 Counter{cSubDelRespFromE2, 2},
3600 Counter{cRestSubDelRespToXapp, 2},
3604 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3605 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3606 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3609 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3610 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3611 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3613 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3614 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3616 //XappConn1 receives both of the responses
3617 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3620 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3622 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3624 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3625 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3626 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3627 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3630 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3632 deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
3634 //Wait that subs is cleaned
3635 mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
3636 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
3638 mainCtrl.VerifyCounterValues(t)
3639 mainCtrl.VerifyAllClean(t)
3642 func TestRESTSameSubsDiffRan(t *testing.T) {
3643 CaseBegin("TestRESTSameSubsDiffRan")
3645 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3646 Counter{cRestSubReqFromXapp, 2},
3647 Counter{cRestSubRespToXapp, 2},
3648 Counter{cSubReqToE2, 2},
3649 Counter{cSubRespFromE2, 2},
3650 Counter{cRestSubNotifToXapp, 2},
3651 Counter{cRestSubDelReqFromXapp, 2},
3652 Counter{cSubDelReqToE2, 2},
3653 Counter{cSubDelRespFromE2, 2},
3654 Counter{cRestSubDelRespToXapp, 2},
3657 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3658 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3659 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3661 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3662 params.SetMeid("RAN_NAME_2")
3663 restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
3664 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3667 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3669 deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
3671 //Wait that subs is cleaned
3672 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3673 waitSubsCleanup(t, e2SubsId2, 10)
3675 mainCtrl.VerifyCounterValues(t)
3676 mainCtrl.VerifyAllClean(t)
3679 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
3680 CaseBegin("TestRESTSubReqRetryInSubmgr start")
3682 // Init counter check
3683 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3684 Counter{cRestSubReqFromXapp, 1},
3685 Counter{cRestSubRespToXapp, 1},
3686 Counter{cSubReqToE2, 1},
3687 Counter{cSubReqTimerExpiry, 1},
3688 Counter{cSubReReqToE2, 1},
3689 Counter{cSubRespFromE2, 1},
3690 Counter{cRestSubNotifToXapp, 1},
3691 Counter{cRestSubDelReqFromXapp, 1},
3692 Counter{cSubDelReqToE2, 1},
3693 Counter{cSubDelRespFromE2, 1},
3694 Counter{cRestSubDelRespToXapp, 1},
3697 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3698 restSubId := xappConn1.SendRESTSubsReq(t, params)
3700 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3702 // Catch the first message and ignore it
3703 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3704 xapp.Logger.Debug("Ignore REST subscriber request for subscriber : %v", restSubId)
3706 // The second request is being handled normally
3707 crereq, cremsg = e2termConn1.RecvSubsReq(t)
3708 xappConn1.ExpectRESTNotification(t, restSubId)
3709 e2termConn1.SendSubsResp(t, crereq, cremsg)
3710 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3712 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3714 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3716 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
3717 //Wait that subs is cleaned
3718 waitSubsCleanup(t, e2SubsId, 10)
3720 mainCtrl.VerifyCounterValues(t)
3721 mainCtrl.VerifyAllClean(t)
3724 //-----------------------------------------------------------------------------
3725 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3728 // +-------+ +---------+ +---------+
3729 // | xapp | | submgr | | e2term |
3730 // +-------+ +---------+ +---------+
3733 // |---------------->| |
3735 // | RESTSubResp | |
3736 // |<----------------| |
3738 // | |------------->|
3742 // | |------------->|
3745 // | |------------->|
3749 // | |------------->|
3753 // | |<-------------|
3756 // |<----------------| |
3758 // | [SUBS DELETE] |
3761 //-----------------------------------------------------------------------------
3763 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
3764 CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
3766 // Init counter check
3767 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3768 Counter{cRestSubReqFromXapp, 1},
3769 Counter{cRestSubRespToXapp, 1},
3770 Counter{cSubReqToE2, 1},
3771 Counter{cSubReReqToE2, 1},
3772 Counter{cSubReqTimerExpiry, 2},
3773 Counter{cRestSubFailNotifToXapp, 1},
3774 Counter{cSubDelReqToE2, 1},
3775 Counter{cSubDelRespFromE2, 1},
3776 Counter{cRestSubDelReqFromXapp, 1},
3777 Counter{cRestSubDelRespToXapp, 1},
3780 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3781 restSubId := xappConn1.SendRESTSubsReq(t, params)
3782 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3784 e2termConn1.RecvSubsReq(t)
3785 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3787 e2termConn1.RecvSubsReq(t)
3788 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3790 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3791 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3792 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3793 xappConn1.WaitRESTNotification(t, restSubId)
3795 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3797 // Wait that subs is cleaned
3798 waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
3799 mainCtrl.VerifyCounterValues(t)
3800 mainCtrl.VerifyAllClean(t)
3803 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
3804 CaseBegin("TestREST2eTermNotRespondingToSubReq start")
3806 // Init counter check
3807 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3808 Counter{cRestSubReqFromXapp, 1},
3809 Counter{cRestSubRespToXapp, 1},
3810 Counter{cSubReqToE2, 1},
3811 Counter{cSubReReqToE2, 1},
3812 Counter{cSubReqTimerExpiry, 2},
3813 Counter{cSubDelReReqToE2, 1},
3814 Counter{cRestSubFailNotifToXapp, 1},
3815 Counter{cSubDelReqToE2, 1},
3816 Counter{cSubDelReqTimerExpiry, 2},
3817 Counter{cRestSubDelReqFromXapp, 1},
3818 Counter{cRestSubDelRespToXapp, 1},
3821 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3822 restSubId := xappConn1.SendRESTSubsReq(t, params)
3823 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3825 e2termConn1.RecvSubsReq(t)
3826 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3828 e2termConn1.RecvSubsReq(t)
3829 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3831 e2termConn1.RecvSubsDelReq(t)
3832 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3834 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3835 e2termConn1.RecvSubsDelReq(t)
3836 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3838 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3840 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3842 waitSubsCleanup(t, e2SubsId, 10)
3843 mainCtrl.VerifyCounterValues(t)
3844 mainCtrl.VerifyAllClean(t)
3847 //-----------------------------------------------------------------------------
3848 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3851 // +-------+ +---------+ +---------+
3852 // | xapp | | submgr | | e2term |
3853 // +-------+ +---------+ +---------+
3856 // |---------------->| |
3858 // | RESTSubResp | |
3859 // |<----------------| |
3861 // | |------------->|
3865 // | |------------->|
3868 // | |------------->|
3872 // | |------------->|
3876 // | |<-------------|
3879 // |<----------------| |
3881 // | [SUBS DELETE] |
3884 //-----------------------------------------------------------------------------
3885 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
3886 CaseBegin("TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr start")
3888 // Init counter check
3889 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3890 Counter{cRestSubReqFromXapp, 1},
3891 Counter{cRestSubRespToXapp, 1},
3892 Counter{cSubReqToE2, 1},
3893 Counter{cSubReReqToE2, 1},
3894 Counter{cSubReqTimerExpiry, 2},
3895 Counter{cRestSubFailNotifToXapp, 1},
3896 Counter{cSubDelReqToE2, 1},
3897 Counter{cSubDelReReqToE2, 1},
3898 Counter{cSubDelReqTimerExpiry, 2},
3899 Counter{cRestSubDelReqFromXapp, 1},
3900 Counter{cRestSubDelRespToXapp, 1},
3903 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3904 restSubId := xappConn1.SendRESTSubsReq(t, params)
3905 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3907 e2termConn1.RecvSubsReq(t)
3908 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3910 e2termConn1.RecvSubsReq(t)
3911 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3913 e2termConn1.RecvSubsDelReq(t)
3914 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3916 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3917 e2termConn1.RecvSubsDelReq(t)
3918 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3920 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3922 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3924 waitSubsCleanup(t, e2SubsId, 10)
3925 mainCtrl.VerifyCounterValues(t)
3926 mainCtrl.VerifyAllClean(t)
3929 //-----------------------------------------------------------------------------
3930 // TestRESTSubReqSubFailRespInSubmgr
3933 // +-------+ +---------+ +---------+
3934 // | xapp | | submgr | | e2term |
3935 // +-------+ +---------+ +---------+
3938 // |---------------->| |
3940 // | RESTSubResp | |
3941 // |<----------------| |
3943 // | |------------->|
3946 // | |<-------------|
3950 // |<----------------| |
3952 // | [SUBS DELETE] |
3955 //-----------------------------------------------------------------------------
3956 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
3957 CaseBegin("TestRESTSubReqSubFailRespInSubmgr")
3959 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3960 Counter{cRestSubReqFromXapp, 1},
3961 Counter{cRestSubRespToXapp, 1},
3962 Counter{cSubReqToE2, 1},
3963 Counter{cSubFailFromE2, 1},
3964 Counter{cRestSubFailNotifToXapp, 1},
3965 Counter{cRestSubDelReqFromXapp, 1},
3966 Counter{cRestSubDelRespToXapp, 1},
3969 const subReqCount int = 1
3970 const e2Timeout int64 = 2
3971 const e2RetryCount int64 = 1
3972 const routingNeeded bool = true
3974 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3975 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
3976 restSubId := xappConn1.SendRESTSubsReq(t, params)
3978 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3979 fparams1 := &teststube2ap.E2StubSubsFailParams{}
3980 fparams1.Set(crereq1)
3981 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3982 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3984 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3985 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
3987 // REST subscription sill there to be deleted
3988 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3990 // Wait that subs is cleaned
3991 waitSubsCleanup(t, e2SubsId, 10)
3993 mainCtrl.VerifyCounterValues(t)
3994 mainCtrl.VerifyAllClean(t)
3997 //-----------------------------------------------------------------------------
3998 // TestRESTSubDelReqRetryInSubmgr
4001 // +-------+ +---------+ +---------+
4002 // | xapp | | submgr | | e2term |
4003 // +-------+ +---------+ +---------+
4005 // | [SUBS CREATE] |
4008 // | RESTSubDelReq | |
4009 // |---------------->| |
4011 // | RESTSubDelResp | |
4012 // |<----------------| |
4014 // | |------------->|
4017 // | |------------->|
4020 // | |<-------------|
4023 //-----------------------------------------------------------------------------
4024 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
4025 CaseBegin("TestRESTSubDelReqRetryInSubmgr")
4027 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4028 Counter{cRestSubReqFromXapp, 1},
4029 Counter{cRestSubRespToXapp, 1},
4030 Counter{cSubReqToE2, 1},
4031 Counter{cSubRespFromE2, 1},
4032 Counter{cRestSubNotifToXapp, 1},
4033 Counter{cRestSubDelReqFromXapp, 1},
4034 Counter{cSubDelReqToE2, 1},
4035 Counter{cSubDelReqTimerExpiry, 1},
4036 Counter{cSubDelReReqToE2, 1},
4037 Counter{cSubDelRespFromE2, 1},
4038 Counter{cRestSubDelRespToXapp, 1},
4041 var params *teststube2ap.RESTSubsReqParams = nil
4042 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4045 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4047 // E2t: Receive 1st SubsDelReq
4048 e2termConn1.RecvSubsDelReq(t)
4050 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4051 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4052 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4054 //Wait that subs is cleaned
4055 waitSubsCleanup(t, e2SubsId, 10)
4057 mainCtrl.VerifyCounterValues(t)
4058 mainCtrl.VerifyAllClean(t)
4061 //-----------------------------------------------------------------------------
4062 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
4065 // +-------+ +---------+ +---------+
4066 // | xapp | | submgr | | e2term |
4067 // +-------+ +---------+ +---------+
4069 // | [SUBS CREATE] |
4072 // | RESTSubDelReq | |
4073 // |---------------->| |
4075 // | RESTSubDelResp | |
4076 // |<----------------| |
4078 // | |------------->|
4081 // | |------------->|
4085 //-----------------------------------------------------------------------------
4086 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
4087 CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr")
4089 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4090 Counter{cRestSubReqFromXapp, 1},
4091 Counter{cRestSubRespToXapp, 1},
4092 Counter{cSubReqToE2, 1},
4093 Counter{cSubRespFromE2, 1},
4094 Counter{cRestSubNotifToXapp, 1},
4095 Counter{cRestSubDelReqFromXapp, 1},
4096 Counter{cSubDelReqToE2, 1},
4097 Counter{cSubDelReqTimerExpiry, 1},
4098 Counter{cSubDelReReqToE2, 1},
4099 Counter{cSubDelRespFromE2, 1},
4100 Counter{cRestSubDelRespToXapp, 1},
4104 var params *teststube2ap.RESTSubsReqParams = nil
4105 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4108 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4110 // E2t: Receive 1st SubsDelReq
4111 e2termConn1.RecvSubsDelReq(t)
4113 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4114 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4115 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4117 //Wait that subs is cleaned
4118 waitSubsCleanup(t, e2SubsId, 10)
4120 mainCtrl.VerifyCounterValues(t)
4121 mainCtrl.VerifyAllClean(t)
4124 //-----------------------------------------------------------------------------
4125 // TestRESTSubDelReqSubDelFailRespInSubmgr
4128 // +-------+ +---------+ +---------+
4129 // | xapp | | submgr | | e2term |
4130 // +-------+ +---------+ +---------+
4132 // | [SUBS CREATE] |
4135 // | RESTSubDelReq | |
4136 // |---------------->| |
4138 // | RESTSubDelResp | |
4139 // |<----------------| |
4141 // | |------------->|
4144 // | |<-------------|
4147 //-----------------------------------------------------------------------------
4148 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
4149 CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr")
4151 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4152 Counter{cRestSubReqFromXapp, 1},
4153 Counter{cRestSubRespToXapp, 1},
4154 Counter{cSubReqToE2, 1},
4155 Counter{cSubRespFromE2, 1},
4156 Counter{cRestSubNotifToXapp, 1},
4157 Counter{cRestSubDelReqFromXapp, 1},
4158 Counter{cSubDelReqToE2, 1},
4159 Counter{cSubDelFailFromE2, 1},
4160 Counter{cRestSubDelRespToXapp, 1},
4164 var params *teststube2ap.RESTSubsReqParams = nil
4165 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4168 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4170 // E2t: Send receive SubsDelReq and send SubsDelFail
4171 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4172 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
4174 //Wait that subs is cleaned
4175 waitSubsCleanup(t, e2SubsId, 10)
4177 mainCtrl.VerifyCounterValues(t)
4178 mainCtrl.VerifyAllClean(t)
4181 //-----------------------------------------------------------------------------
4182 // TestRESTSubReqAndSubDelOkSameAction
4185 // +-------+ +-------+ +---------+ +---------+
4186 // | xapp2 | | xapp1 | | submgr | | e2term |
4187 // +-------+ +-------+ +---------+ +---------+
4189 // | | RESTSubReq1 | |
4190 // | |---------------->| |
4192 // | | RESTSubResp1 | |
4193 // | |<----------------| |
4196 // | | |------------->|
4198 // | | |<-------------|
4199 // | | RESTNotif1 | |
4200 // | |<----------------| |
4202 // | RESTSubReq2 | |
4203 // |------------------------------>| |
4205 // | RESTSubResp2 | |
4206 // |<------------------------------| |
4208 // | | RESTNotif2 | |
4209 // |<------------------------------| |
4211 // | | RESTSubDelReq1 | |
4212 // | |---------------->| |
4214 // | | RESTSubDelResp1 | |
4215 // | |<----------------| |
4217 // | RESTSubDelReq2 | |
4218 // |------------------------------>| |
4220 // | RESTSubDelResp2 | |
4221 // |<------------------------------| |
4223 // | | | SubDelReq2 |
4224 // | | |------------->|
4226 // | | | SubDelResp2 |
4227 // | | |<-------------|
4230 //-----------------------------------------------------------------------------
4231 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
4232 CaseBegin("TestRESTSubReqAndSubDelOkSameAction")
4234 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4235 Counter{cRestSubReqFromXapp, 2},
4236 Counter{cRestSubRespToXapp, 2},
4237 Counter{cSubReqToE2, 1},
4238 Counter{cSubRespFromE2, 1},
4239 Counter{cRestSubNotifToXapp, 2},
4240 Counter{cMergedSubscriptions, 1},
4241 Counter{cUnmergedSubscriptions, 1},
4242 Counter{cRestSubDelReqFromXapp, 2},
4243 Counter{cSubDelReqToE2, 1},
4244 Counter{cSubDelRespFromE2, 1},
4245 Counter{cRestSubDelRespToXapp, 2},
4249 var params *teststube2ap.RESTSubsReqParams = nil
4252 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4253 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4256 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4257 params.SetMeid("RAN_NAME_1")
4259 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4260 xappConn2.ExpectAnyNotification(t)
4261 waiter := rtmgrHttp.AllocNextSleep(10, true)
4262 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4263 waiter.WaitResult(t)
4264 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
4265 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
4266 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
4268 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
4271 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4274 deleteXapp2Subscription(t, &restSubId2)
4276 //Wait that subs is cleaned
4277 waitSubsCleanup(t, e2SubsId2, 10)
4278 mainCtrl.VerifyCounterValues(t)
4279 mainCtrl.VerifyAllClean(t)
4282 //-----------------------------------------------------------------------------
4283 // TestSubReqAndSubDelOkSameActionParallel
4286 // +-------+ +-------+ +---------+ +---------+
4287 // | xapp2 | | xapp1 | | submgr | | e2term |
4288 // +-------+ +-------+ +---------+ +---------+
4293 // | |------------->| |
4296 // | | |------------->|
4298 // |--------------------------->| |
4300 // | | |<-------------|
4302 // | |<-------------| |
4304 // | | |------------->|
4307 // | | |<-------------|
4309 // |<---------------------------| |
4311 // | | SubDelReq 1 | |
4312 // | |------------->| |
4314 // | | SubDelResp 1 | |
4315 // | |<-------------| |
4317 // | SubDelReq 2 | |
4318 // |--------------------------->| |
4320 // | | | SubDelReq 2 |
4321 // | | |------------->|
4323 // | | | SubDelReq 2 |
4324 // | | |------------->|
4326 // | SubDelResp 2 | |
4327 // |<---------------------------| |
4329 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
4330 CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel")
4332 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4333 Counter{cRestSubReqFromXapp, 2},
4334 Counter{cRestSubRespToXapp, 2},
4335 Counter{cSubReqToE2, 2},
4336 Counter{cSubRespFromE2, 2},
4337 Counter{cRestSubNotifToXapp, 2},
4338 Counter{cRestSubDelReqFromXapp, 2},
4339 Counter{cSubDelReqToE2, 2},
4340 Counter{cSubDelRespFromE2, 2},
4341 Counter{cRestSubDelRespToXapp, 2},
4344 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4345 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4346 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4348 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4349 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4351 xappConn1.ExpectRESTNotification(t, restSubId1)
4352 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4353 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4355 xappConn2.ExpectRESTNotification(t, restSubId2)
4356 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
4357 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
4358 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4361 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4362 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4363 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4364 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4367 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4368 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
4369 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
4371 waitSubsCleanup(t, e2SubsId2, 10)
4372 mainCtrl.VerifyCounterValues(t)
4373 mainCtrl.VerifyAllClean(t)
4376 //-----------------------------------------------------------------------------
4377 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
4380 // +-------+ +-------+ +---------+ +---------+
4381 // | xapp2 | | xapp1 | | submgr | | e2term |
4382 // +-------+ +-------+ +---------+ +---------+
4386 // | | RESTSubReq1 | |
4387 // | |---------------->| |
4389 // | | RESTSubResp1 | |
4390 // | |<----------------| |
4392 // | | |------------->|
4393 // | RESTSubReq2 | |
4394 // |------------------------------>| |
4396 // | RESTSubResp2 | |
4397 // |<------------------------------| |
4399 // | | |------------->|
4402 // | | | SubDelReq |
4403 // | | |------------->|
4405 // | | | SubDelResp |
4406 // | | |<-------------|
4407 // | | RESTNotif1 | |
4408 // | | unsuccess | |
4409 // | |<----------------| |
4411 // | | unsuccess | |
4412 // |<------------------------------| |
4414 // | | RESTSubDelReq1 | |
4415 // | |---------------->| |
4417 // | | RESTSubDelResp1 | |
4418 // | |<----------------| |
4420 // | RESTSubDelReq2 | |
4421 // |------------------------------>| |
4423 // | RESTSubDelResp2 | |
4424 // |<------------------------------| |
4426 //-----------------------------------------------------------------------------
4427 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
4428 CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
4430 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4431 Counter{cRestSubReqFromXapp, 2},
4432 Counter{cMergedSubscriptions, 1},
4433 Counter{cRestSubRespToXapp, 2},
4434 Counter{cSubReqToE2, 1},
4435 Counter{cSubReqTimerExpiry, 2},
4436 Counter{cSubReReqToE2, 1},
4437 Counter{cRestSubFailNotifToXapp, 2},
4438 Counter{cUnmergedSubscriptions, 1},
4439 Counter{cRestSubDelReqFromXapp, 2},
4440 Counter{cSubDelReqToE2, 1},
4441 Counter{cSubDelRespFromE2, 1},
4442 Counter{cRestSubDelRespToXapp, 2},
4444 const subReqCount int = 1
4447 params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4448 restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
4449 crereq1, _ := e2termConn1.RecvSubsReq(t)
4452 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4453 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4454 params2.SetMeid("RAN_NAME_1")
4455 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4456 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4458 //Req1 (retransmitted)
4459 e2termConn1.RecvSubsReq(t)
4461 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4463 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4464 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4466 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4467 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4468 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4469 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4472 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4475 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4477 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
4479 //Wait that subs is cleaned
4480 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4481 mainCtrl.VerifyCounterValues(t)
4482 mainCtrl.VerifyAllClean(t)
4485 //-----------------------------------------------------------------------------
4486 // TestRESTSubReqAndSubDelNokSameActionParallel
4489 // +-------+ +-------+ +---------+ +---------+
4490 // | xapp2 | | xapp1 | | submgr | | e2term |
4491 // +-------+ +-------+ +---------+ +---------+
4495 // | | RESTSubReq1 | |
4496 // | |---------------->| |
4498 // | | RESTSubResp1 | |
4499 // | |<----------------| |
4501 // | | |------------->|
4502 // | RESTSubReq2 | |
4503 // |------------------------------>| |
4505 // | RESTSubDelResp2 | |
4506 // |<------------------------------| |
4508 // | | |<-------------|
4510 // | | RESTNotif1 | |
4511 // | | unsuccess | |
4512 // | |<----------------| |
4514 // | | unsuccess | |
4515 // |<------------------------------| |
4517 // | | RESTSubDelReq1 | | There is no need for xApp to send delete for failed subscriptions but some xApp might do so.
4518 // | |---------------->| |
4520 // | | RESTSubDelResp1 | |
4521 // | |<----------------| |
4523 // | RESTSubDelReq2 | |
4524 // |------------------------------>| |
4526 // | RESTSubDelResp2 | |
4527 // |<------------------------------| |
4529 //-----------------------------------------------------------------------------
4530 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
4531 CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
4533 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4534 Counter{cRestSubReqFromXapp, 2},
4535 Counter{cMergedSubscriptions, 1},
4536 Counter{cRestSubRespToXapp, 2},
4537 Counter{cSubReqToE2, 1},
4538 Counter{cSubFailFromE2, 1},
4539 Counter{cRestSubFailNotifToXapp, 2},
4540 Counter{cUnmergedSubscriptions, 1},
4541 Counter{cRestSubDelReqFromXapp, 2},
4542 Counter{cRestSubDelRespToXapp, 2},
4545 const subReqCount int = 1
4548 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4549 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4550 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4553 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4554 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4555 params2.SetMeid("RAN_NAME_1")
4556 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4557 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4559 // E2t: send SubsFail (first)
4560 fparams1 := &teststube2ap.E2StubSubsFailParams{}
4561 fparams1.Set(crereq1)
4562 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
4564 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4565 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4566 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4567 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4568 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4571 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4574 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4576 //Wait that subs is cleaned
4577 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4578 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
4579 mainCtrl.VerifyCounterValues(t)
4580 mainCtrl.VerifyAllClean(t)
4583 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
4584 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4586 // Init counter check
4587 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4588 Counter{cRestSubReqFromXapp, 1},
4589 Counter{cRestSubRespToXapp, 1},
4590 Counter{cSubReqToE2, 1},
4591 Counter{cSubRespFromE2, 1},
4592 Counter{cRestSubNotifToXapp, 1},
4593 Counter{cRestSubDelReqFromXapp, 1},
4594 Counter{cSubDelReqToE2, 1},
4595 Counter{cSubDelRespFromE2, 1},
4596 Counter{cRestSubDelRespToXapp, 1},
4599 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4600 restSubId := xappConn1.SendRESTSubsReq(t, params)
4601 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
4603 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4604 xappConn1.ExpectRESTNotification(t, restSubId)
4605 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4606 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4607 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
4609 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4610 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4611 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4613 // Wait that subs is cleaned
4614 waitSubsCleanup(t, e2SubsId, 10)
4615 mainCtrl.VerifyCounterValues(t)
4616 mainCtrl.VerifyAllClean(t)
4619 //-----------------------------------------------------------------------------
4620 // TestRESTSubReqPolicyChangeAndSubDelOk
4623 // +-------+ +---------+ +---------+
4624 // | xapp | | submgr | | e2term |
4625 // +-------+ +---------+ +---------+
4628 // |---------------->| |
4630 // | RESTSubResp | |
4631 // |<----------------| |
4633 // | |------------->|
4636 // | |<-------------|
4639 // |<----------------| |
4642 // |---------------->| |
4644 // | RESTSubResp | |
4645 // |<----------------| |
4647 // | |------------->|
4650 // | |<-------------|
4653 // |<----------------| |
4655 // | RESTSubDelReq | |
4656 // |---------------->| |
4659 // | |------------->|
4662 // | |<-------------|
4664 // | RESTSubDelResp | |
4665 // |<----------------| |
4667 //-----------------------------------------------------------------------------
4668 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
4669 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4671 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4672 Counter{cRestSubReqFromXapp, 2},
4673 Counter{cRestSubRespToXapp, 2},
4674 Counter{cSubReqToE2, 2},
4675 Counter{cSubRespFromE2, 2},
4676 Counter{cRestSubNotifToXapp, 2},
4677 Counter{cRestSubDelReqFromXapp, 1},
4678 Counter{cSubDelReqToE2, 1},
4679 Counter{cSubDelRespFromE2, 1},
4680 Counter{cRestSubDelRespToXapp, 1},
4683 const subReqCount int = 1
4684 const e2Timeout int64 = 1
4685 const e2RetryCount int64 = 0
4686 const routingNeeded bool = true
4689 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4690 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4691 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4694 // GetRESTSubsReqPolicyParams sets some counters on tc side.
4696 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4697 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4698 params.SetSubscriptionID(&restSubId)
4699 params.SetTimeToWait("w200ms")
4700 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
4703 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4705 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4706 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4708 // Wait that subs is cleaned
4709 waitSubsCleanup(t, e2SubsId, 10)
4710 mainCtrl.VerifyCounterValues(t)
4711 mainCtrl.VerifyAllClean(t)
4714 //-----------------------------------------------------------------------------
4715 // TestRESTSubReqPolicyChangeNOk
4718 // +-------+ +---------+ +---------+
4719 // | xapp | | submgr | | e2term |
4720 // +-------+ +---------+ +---------+
4723 // |---------------->| |
4725 // | RESTSubResp | |
4726 // |<----------------| |
4728 // | |------------->|
4731 // | |<-------------|
4734 // |<----------------| |
4737 // |---------------->| |
4739 // | RESTSubUpdateFail(400 Bad request)
4741 // | RESTSubDelReq | |
4742 // |---------------->| |
4745 // | |------------->|
4748 // | |<-------------|
4750 // | RESTSubDelResp | |
4751 // |<----------------| |
4753 //-----------------------------------------------------------------------------
4754 func TestRESTSubReqPolicyChangeNOk(t *testing.T) {
4755 CaseBegin("TestRESTSubReqPolicyChangeNOk")
4757 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4758 Counter{cRestSubReqFromXapp, 2},
4759 Counter{cRestSubRespToXapp, 1},
4760 Counter{cSubReqToE2, 1},
4761 Counter{cSubRespFromE2, 1},
4762 Counter{cRestSubNotifToXapp, 1},
4763 Counter{cRestSubFailToXapp, 1},
4764 Counter{cRestSubDelReqFromXapp, 1},
4765 Counter{cSubDelReqToE2, 1},
4766 Counter{cSubDelRespFromE2, 1},
4767 Counter{cRestSubDelRespToXapp, 1},
4771 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4772 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4775 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4777 restSubIdUpd := strings.ToUpper(restSubId) // This makes RESTSubReq to fail
4778 params.SetSubscriptionID(&restSubIdUpd)
4779 params.SetTimeToWait("w200ms")
4781 restSubId2 := xappConn1.SendRESTSubsReq(t, params)
4782 assert.Equal(t, restSubId2, "")
4785 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4787 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4788 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4790 // Wait that subs is cleaned
4791 waitSubsCleanup(t, e2SubsId, 10)
4792 mainCtrl.VerifyCounterValues(t)
4793 mainCtrl.VerifyAllClean(t)
4796 //-----------------------------------------------------------------------------
4797 // TestRESTSubReqAndSubDelOkTwoE2termParallel
4800 // +-------+ +---------+ +---------+ +---------+
4801 // | xapp | | submgr | | e2term1 | | e2term2 |
4802 // +-------+ +---------+ +---------+ +---------+
4806 // | RESTSubReq1 | | |
4807 // |---------------->| | |
4809 // | RESTSubResp1 | | |
4810 // |<----------------| | |
4812 // | |------------->| |
4814 // | RESTSubReq2 | | |
4815 // |---------------->| | |
4817 // | RESTSubResp2 | | |
4818 // |<----------------| | |
4820 // | |---------------------------->|
4823 // | |<-------------| |
4824 // | RESTNotif1 | | |
4825 // |<----------------| | |
4827 // | |<----------------------------|
4828 // | RESTNotif2 | | |
4829 // |<----------------| | |
4831 // | [SUBS 1 DELETE] | |
4833 // | [SUBS 2 DELETE] | |
4836 //-----------------------------------------------------------------------------
4837 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
4838 CaseBegin("TestRESTSubReqAndSubDelOkTwoE2termParallel")
4840 // Init counter check
4841 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4842 Counter{cRestSubReqFromXapp, 2},
4843 Counter{cRestSubRespToXapp, 2},
4844 Counter{cSubReqToE2, 2},
4845 Counter{cSubRespFromE2, 2},
4846 Counter{cRestSubNotifToXapp, 2},
4847 Counter{cRestSubDelReqFromXapp, 2},
4848 Counter{cSubDelReqToE2, 2},
4849 Counter{cSubDelRespFromE2, 2},
4850 Counter{cRestSubDelRespToXapp, 2},
4853 const subReqCount int = 1
4856 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4857 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4858 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4861 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4862 params.SetMeid("RAN_NAME_11")
4863 // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
4864 // would not work as notification would not be received
4865 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4866 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
4869 xappConn1.ExpectRESTNotification(t, restSubId1)
4870 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4871 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4872 xapp.Logger.Debug("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
4875 xappConn2.ExpectRESTNotification(t, restSubId2)
4876 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
4877 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4878 xapp.Logger.Debug("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
4881 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4882 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4883 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4885 // Wait that subs is cleaned
4886 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4889 xappConn1.SendRESTSubsDelReq(t, &restSubId2)
4890 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
4891 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
4893 // Wait that subs is cleaned
4894 waitSubsCleanup(t, e2SubsId2, 10)
4896 mainCtrl.VerifyCounterValues(t)
4897 mainCtrl.VerifyAllClean(t)
4900 //-----------------------------------------------------------------------------
4901 // TestRESTSubReqAsn1EncodeFail
4903 // In this case submgr send RICSubscriptionDeleteRequest after encode failure which should not happen!
4905 // +-------+ +---------+ +---------+
4906 // | xapp | | submgr | | e2term |
4907 // +-------+ +---------+ +---------+
4910 // |---------------->| |
4912 // | RESTSubResp | |
4913 // |<----------------| |
4914 // | RESTSubDelReq | |
4915 // |---------------->| |
4916 // | RESTSubDelResp | |
4918 // |<----------------| |
4921 //-----------------------------------------------------------------------------
4922 func TestRESTSubReqAsn1EncodeFail(t *testing.T) {
4923 CaseBegin("TestRESTSubReqAsn1EncodeFail")
4925 xapp.Logger.Debug("Xapp-frame, v0.8.1 sufficient REST API validation")
4929 //-----------------------------------------------------------------------------
4930 // TestRESTSubReqInsertAndSubDelOk
4933 // +-------+ +---------+ +---------+
4934 // | xapp | | submgr | | e2term |
4935 // +-------+ +---------+ +---------+
4938 // |---------------->| |
4940 // | RESTSubResp | |
4941 // |<----------------| |
4944 // | |------------->|
4947 // | |<-------------|
4949 // |<----------------| |
4952 // | RESTSubDelReq | |
4953 // |---------------->| |
4956 // | |------------->|
4959 // | |<-------------|
4961 // | RESTSubDelResp| |
4962 // |<----------------| |
4964 //-----------------------------------------------------------------------------
4965 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
4966 CaseBegin("TestRESTInsertSubReqAndSubDelOk")
4968 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4969 Counter{cRestSubReqFromXapp, 1},
4970 Counter{cRestSubRespToXapp, 1},
4971 Counter{cSubReqToE2, 1},
4972 Counter{cSubRespFromE2, 1},
4973 Counter{cRestSubNotifToXapp, 1},
4974 Counter{cRestSubDelReqFromXapp, 1},
4975 Counter{cSubDelReqToE2, 1},
4976 Counter{cSubDelRespFromE2, 1},
4977 Counter{cRestSubDelRespToXapp, 1},
4980 const subReqCount int = 1
4982 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4983 params.SetSubActionTypes("insert")
4986 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4989 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4991 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4992 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4994 // Wait that subs is cleaned
4995 waitSubsCleanup(t, e2SubsId, 10)
4996 mainCtrl.VerifyCounterValues(t)
4997 mainCtrl.VerifyAllClean(t)
5000 //-----------------------------------------------------------------------------
5001 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
5004 // +-------+ +---------+ +---------+
5005 // | xapp | | submgr | | e2term |
5006 // +-------+ +---------+ +---------+
5009 // |------------->| |
5011 // | RESTSubResp | |
5012 // |<-------------| |
5014 // | |------------->|
5019 // | Submgr restart |
5023 // | |------------->|
5026 // | |<-------------|
5030 // |<-------------| |
5032 // | RESTSubDelReq| |
5033 // |------------->| |
5035 // |RESTSubDelResp| |
5036 // |<-------------| |
5038 //-----------------------------------------------------------------------------
5039 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
5040 CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle")
5042 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5043 Counter{cRestSubReqFromXapp, 1},
5044 Counter{cRestSubRespToXapp, 1},
5045 Counter{cSubReqToE2, 1},
5046 Counter{cSubDelReqFromXapp, 1},
5047 Counter{cSubDelReqToE2, 1},
5048 Counter{cSubDelRespFromE2, 1},
5049 Counter{cRestSubDelReqFromXapp, 1},
5050 Counter{cRestSubDelRespToXapp, 1},
5053 const subReqCount int = 1
5055 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5058 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
5059 restSubId := xappConn1.SendRESTSubsReq(t, params)
5060 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5062 e2termConn1.RecvSubsReq(t)
5064 mainCtrl.SetResetTestFlag(t, false)
5066 mainCtrl.SimulateRestart(t)
5067 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5069 // Deleletion of uncompleted subscription
5070 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5071 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5074 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5076 xappConn1.TestMsgChanEmpty(t)
5077 e2termConn1.TestMsgChanEmpty(t)
5078 mainCtrl.wait_registry_empty(t, 10)
5080 mainCtrl.VerifyCounterValues(t)
5081 mainCtrl.VerifyAllClean(t)
5084 //-----------------------------------------------------------------------------
5085 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
5088 // +-------+ +---------+ +---------+
5089 // | xapp | | submgr | | e2term |
5090 // +-------+ +---------+ +---------+
5093 // |---------------->| |
5095 // | RESTSubResp | |
5096 // |<----------------| |
5098 // | |------------->|
5101 // | |<-------------|
5104 // |<----------------| |
5107 // | Submgr restart |
5109 // | RESTSubDelReq | |
5110 // |---------------->| |
5113 // | |------------->|
5116 // | |<-------------|
5118 // | RESTSubDelResp | |
5119 // |<----------------| |
5121 //-----------------------------------------------------------------------------
5123 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
5124 CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle")
5126 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5127 Counter{cRestSubReqFromXapp, 1},
5128 Counter{cRestSubRespToXapp, 1},
5129 Counter{cSubReqToE2, 1},
5130 Counter{cSubRespFromE2, 1},
5131 Counter{cRestSubNotifToXapp, 1},
5132 Counter{cRestSubDelReqFromXapp, 1},
5133 Counter{cSubDelReqToE2, 1},
5134 Counter{cSubDelRespFromE2, 1},
5135 Counter{cRestSubDelRespToXapp, 1},
5138 // Create subscription
5139 var params *teststube2ap.RESTSubsReqParams = nil
5140 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5141 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5143 // Check subscription
5144 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5146 mainCtrl.SimulateRestart(t)
5147 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5149 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5150 // That needs to be completed before successful subscription query is possible
5151 <-time.After(time.Second * 1)
5153 // Check subscription
5154 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5156 // Delete subscription
5157 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
5159 //Wait that subs is cleaned
5160 waitSubsCleanup(t, e2SubsId, 10)
5162 mainCtrl.VerifyCounterValues(t)
5163 mainCtrl.VerifyAllClean(t)
5166 //-----------------------------------------------------------------------------
5167 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
5170 // +-------+ +-------+ +---------+ +---------+
5171 // | xapp2 | | xapp1 | | submgr | | e2term |
5172 // +-------+ +-------+ +---------+ +---------+
5174 // | | RESTSubReq1 | |
5175 // | |---------------->| |
5177 // | | RESTSubResp1 | |
5178 // | |<----------------| |
5181 // | | |------------->|
5183 // | | |<-------------|
5184 // | | RESTNotif1 | |
5185 // | |<----------------| |
5187 // | RESTSubReq2 | |
5188 // |------------------------------>| |
5190 // | RESTSubResp2 | |
5191 // |<------------------------------| |
5193 // | | RESTNotif2 | |
5194 // |<------------------------------| |
5196 // | | Submgr restart |
5198 // | | RESTSubDelReq1 | |
5199 // | |---------------->| |
5201 // | | RESTSubDelResp1 | |
5202 // | |<----------------| |
5204 // | | Submgr restart |
5206 // | RESTSubDelReq2 | |
5207 // |------------------------------>| |
5209 // | RESTSubDelResp2 | |
5210 // |<------------------------------| |
5212 // | | | SubDelReq2 |
5213 // | | |------------->|
5215 // | | | SubDelResp2 |
5216 // | | |<-------------|
5219 //-----------------------------------------------------------------------------
5220 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
5221 CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
5223 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5224 Counter{cRestSubReqFromXapp, 2},
5225 Counter{cRestSubRespToXapp, 2},
5226 Counter{cSubReqToE2, 1},
5227 Counter{cSubRespFromE2, 1},
5228 Counter{cRestSubNotifToXapp, 2},
5229 Counter{cMergedSubscriptions, 1},
5230 Counter{cUnmergedSubscriptions, 1},
5231 Counter{cRestSubDelReqFromXapp, 2},
5232 Counter{cSubDelReqToE2, 1},
5233 Counter{cSubDelRespFromE2, 1},
5234 Counter{cRestSubDelRespToXapp, 2},
5237 // Create subscription 1
5238 var params *teststube2ap.RESTSubsReqParams = nil
5239 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5240 xapp.Logger.Debug("Send REST subscriber request for subscriber 1 : %v", restSubId1)
5242 // Create subscription 2 with same action
5243 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5244 params.SetMeid("RAN_NAME_1")
5245 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
5246 xappConn2.ExpectAnyNotification(t)
5247 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5248 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5249 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
5250 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
5252 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
5254 mainCtrl.SimulateRestart(t)
5255 xapp.Logger.Debug("mainCtrl.SimulateRestart done 1")
5257 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5258 // That needs to be completed before successful subscription delete is possible
5259 <-time.After(time.Second * 1)
5261 // Delete subscription 1, and wait until it has removed the first endpoint
5262 subepcnt := mainCtrl.get_subs_entrypoint_cnt(t, e2SubsId1)
5263 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5264 mainCtrl.wait_subs_entrypoint_cnt_change(t, e2SubsId1, subepcnt, 10)
5266 // Above wait does not work correctly anymore as this delay makes this test case work
5267 //<-time.After(time.Second * 1)
5269 mainCtrl.SimulateRestart(t)
5270 xapp.Logger.Debug("mainCtrl.SimulateRestart done 2")
5272 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5273 // That needs to be completed before successful subscription query is possible
5274 <-time.After(time.Second * 1)
5276 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
5278 // Delete subscription 2
5279 deleteXapp2Subscription(t, &restSubId2)
5281 //Wait that subs is cleaned
5282 waitSubsCleanup(t, e2SubsId2, 10)
5284 mainCtrl.VerifyCounterValues(t)
5285 mainCtrl.VerifyAllClean(t)
5288 //-----------------------------------------------------------------------------
5289 // TestRESTReportSubReqAndSubDelOk
5292 // +-------+ +---------+ +---------+
5293 // | xapp | | submgr | | e2term |
5294 // +-------+ +---------+ +---------+
5297 // |---------------->| |
5299 // | RESTSubResp | |
5300 // |<----------------| |
5303 // | |------------->|
5306 // | |<-------------|
5308 // |<----------------| |
5310 // | |------------->|
5313 // | |<-------------|
5315 // |<----------------| |
5319 // | RESTSubDelReq | |
5320 // |---------------->| |
5323 // | |------------->|
5326 // | |<-------------|
5328 // | RESTSubDelResp| |
5329 // |<----------------| |
5331 //-----------------------------------------------------------------------------
5333 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
5334 CaseBegin("TestRESTReportSubReqAndSubDelOk")
5335 const subReqCount int = 1
5337 RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
5340 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5341 xapp.Logger.Debug("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
5344 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5345 restSubId := xappConn1.SendRESTSubsReq(t, params)
5347 var e2SubsId []uint32
5348 for i := 0; i < subReqCount; i++ {
5349 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5350 xappConn1.ExpectRESTNotification(t, restSubId)
5352 e2termConn1.SendSubsResp(t, crereq, cremsg)
5353 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5354 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5355 e2SubsId = append(e2SubsId, instanceId)
5356 resp, _ := xapp.Subscription.QuerySubscriptions()
5357 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
5358 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
5359 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
5364 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5366 for i := 0; i < subReqCount; i++ {
5367 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5368 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5371 // Wait that subs is cleaned
5372 for i := 0; i < subReqCount; i++ {
5373 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5376 xappConn1.TestMsgChanEmpty(t)
5377 e2termConn1.TestMsgChanEmpty(t)
5378 mainCtrl.wait_registry_empty(t, 10)
5379 mainCtrl.VerifyAllClean(t)
5383 func TestRESTPolicySubReqAndSubDelOk(t *testing.T) { was in comments already
5384 CaseBegin("TestRESTPolicySubReqAndSubDelOk")
5388 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5392 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5395 func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5396 xapp.Logger.Debug("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
5399 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5400 restSubId := xappConn1.SendRESTSubsReq(t, params)
5402 var e2SubsId []uint32
5403 for i := 0; i < subReqCount; i++ {
5404 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5405 xappConn1.ExpectRESTNotification(t, restSubId)
5406 e2termConn1.SendSubsResp(t, crereq, cremsg)
5407 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5408 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5409 e2SubsId = append(e2SubsId, instanceId)
5413 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5415 for i := 0; i < subReqCount; i++ {
5416 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5417 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5420 // Wait that subs is cleaned
5421 for i := 0; i < subReqCount; i++ {
5422 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5424 xappConn1.TestMsgChanEmpty(t)
5425 e2termConn1.TestMsgChanEmpty(t)
5426 mainCtrl.wait_registry_empty(t, 10)
5427 mainCtrl.VerifyAllClean(t)
5430 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
5432 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5433 Counter{cRestSubReqFromXapp, 1},
5434 Counter{cRestSubRespToXapp, 1},
5435 Counter{cSubReqToE2, 2},
5436 Counter{cSubRespFromE2, 2},
5437 Counter{cRestSubNotifToXapp, 2},
5438 Counter{cRestSubDelReqFromXapp, 1},
5439 Counter{cSubDelReqToE2, 2},
5440 Counter{cSubDelRespFromE2, 2},
5441 Counter{cRestSubDelRespToXapp, 1},
5444 const subReqCount int = 2
5447 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5448 restSubId := xappConn1.SendRESTSubsReq(t, params)
5449 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5451 assert.Equal(t, len(e2SubsIds), 2)
5454 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5455 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5457 xappConn1.TestMsgChanEmpty(t)
5458 e2termConn1.TestMsgChanEmpty(t)
5459 mainCtrl.wait_registry_empty(t, 10)
5461 mainCtrl.VerifyCounterValues(t)
5462 mainCtrl.VerifyAllClean(t)
5464 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
5466 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5467 Counter{cRestSubReqFromXapp, 1},
5468 Counter{cRestSubRespToXapp, 1},
5469 Counter{cSubReqToE2, 19},
5470 Counter{cSubRespFromE2, 19},
5471 Counter{cRestSubNotifToXapp, 19},
5472 Counter{cRestSubDelReqFromXapp, 1},
5473 Counter{cSubDelReqToE2, 19},
5474 Counter{cSubDelRespFromE2, 19},
5475 Counter{cRestSubDelRespToXapp, 1},
5478 const subReqCount int = 19
5480 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5481 restSubId := xappConn1.SendRESTSubsReq(t, params)
5482 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5484 assert.Equal(t, len(e2SubsIds), 19)
5486 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5487 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5489 xappConn1.TestMsgChanEmpty(t)
5490 e2termConn1.TestMsgChanEmpty(t)
5491 mainCtrl.wait_registry_empty(t, 10)
5493 mainCtrl.VerifyCounterValues(t)
5494 mainCtrl.VerifyAllClean(t)
5497 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
5501 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5502 Counter{cRestSubReqFromXapp, 1},
5503 Counter{cRestSubRespToXapp, 1},
5504 Counter{cSubReqToE2, uint64(subReqCount)},
5505 Counter{cSubRespFromE2, uint64(subReqCount)},
5506 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5507 Counter{cRestSubDelReqFromXapp, 1},
5508 Counter{cSubDelReqToE2, uint64(subReqCount)},
5509 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5510 Counter{cRestSubDelRespToXapp, 1},
5514 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5515 restSubId := xappConn1.SendRESTSubsReq(t, params)
5516 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5518 assert.Equal(t, len(e2SubsIds), subReqCount)
5521 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5522 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5524 xappConn1.TestMsgChanEmpty(t)
5525 e2termConn1.TestMsgChanEmpty(t)
5526 mainCtrl.wait_registry_empty(t, 10)
5528 mainCtrl.VerifyCounterValues(t)
5529 mainCtrl.VerifyAllClean(t)
5532 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
5536 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5537 Counter{cRestSubReqFromXapp, 1},
5538 Counter{cRestSubRespToXapp, 1},
5539 Counter{cSubReqToE2, uint64(subReqCount)},
5540 Counter{cSubRespFromE2, uint64(subReqCount)},
5541 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5542 Counter{cRestSubDelReqFromXapp, 1},
5543 Counter{cSubDelReqToE2, uint64(subReqCount)},
5544 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5545 Counter{cRestSubDelRespToXapp, 1},
5549 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5550 restSubId := xappConn1.SendRESTSubsReq(t, params)
5551 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5553 assert.Equal(t, len(e2SubsIds), subReqCount)
5556 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5557 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5559 xappConn1.TestMsgChanEmpty(t)
5560 e2termConn1.TestMsgChanEmpty(t)
5561 mainCtrl.wait_registry_empty(t, 10)
5563 mainCtrl.VerifyCounterValues(t)
5564 mainCtrl.VerifyAllClean(t)
5567 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
5571 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5572 Counter{cRestSubReqFromXapp, 1},
5573 Counter{cRestSubRespToXapp, 1},
5574 Counter{cSubReqToE2, uint64(subReqCount)},
5575 Counter{cSubRespFromE2, uint64(subReqCount)},
5576 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5577 Counter{cRestSubDelReqFromXapp, 1},
5578 Counter{cSubDelReqToE2, uint64(subReqCount)},
5579 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5580 Counter{cRestSubDelRespToXapp, 1},
5584 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5585 restSubId := xappConn1.SendRESTSubsReq(t, params)
5586 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5588 assert.Equal(t, len(e2SubsIds), subReqCount)
5591 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5592 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5594 xappConn1.TestMsgChanEmpty(t)
5595 e2termConn1.TestMsgChanEmpty(t)
5596 mainCtrl.wait_registry_empty(t, 10)
5598 mainCtrl.VerifyCounterValues(t)
5599 mainCtrl.VerifyAllClean(t)
5602 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
5603 CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
5605 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5606 Counter{cRestSubReqFromXapp, 2},
5607 Counter{cRestSubRespToXapp, 2},
5608 Counter{cSubReqToE2, 2},
5609 Counter{cSubRespFromE2, 2},
5610 Counter{cRestSubNotifToXapp, 2},
5611 Counter{cRestSubDelReqFromXapp, 2},
5612 Counter{cSubDelReqToE2, 2},
5613 Counter{cSubDelRespFromE2, 2},
5614 Counter{cRestSubDelRespToXapp, 2},
5618 var params *teststube2ap.RESTSubsReqParams = nil
5621 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5622 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5624 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5627 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5628 params.SetMeid("RAN_NAME_1")
5629 eventTriggerDefinition := []int64{1234, 1}
5630 params.SetSubEventTriggerDefinition(eventTriggerDefinition)
5632 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5633 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5634 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5635 xappConn2.ExpectRESTNotification(t, restSubId2)
5636 e2termConn1.SendSubsResp(t, crereq, cremsg)
5637 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5639 deleteXapp1Subscription(t, &restSubId1)
5640 deleteXapp2Subscription(t, &restSubId2)
5642 waitSubsCleanup(t, e2SubsId1, 10)
5643 waitSubsCleanup(t, e2SubsId2, 10)
5645 mainCtrl.VerifyCounterValues(t)
5646 mainCtrl.VerifyAllClean(t)
5649 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
5650 CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
5652 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5653 Counter{cRestSubReqFromXapp, 2},
5654 Counter{cRestSubRespToXapp, 2},
5655 Counter{cSubReqToE2, 2},
5656 Counter{cSubRespFromE2, 2},
5657 Counter{cRestSubNotifToXapp, 2},
5658 Counter{cRestSubDelReqFromXapp, 2},
5659 Counter{cSubDelReqToE2, 2},
5660 Counter{cSubDelRespFromE2, 2},
5661 Counter{cRestSubDelRespToXapp, 2},
5665 var params *teststube2ap.RESTSubsReqParams = nil
5668 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5669 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5671 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5674 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5675 params.SetMeid("RAN_NAME_1")
5677 actionId := int64(1)
5678 actionType := "report"
5679 actionDefinition := []int64{5678, 1}
5680 subsequestActionType := "continue"
5681 timeToWait := "w10ms"
5682 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
5684 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5685 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5686 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5687 xappConn2.ExpectRESTNotification(t, restSubId2)
5688 e2termConn1.SendSubsResp(t, crereq, cremsg)
5689 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5691 deleteXapp1Subscription(t, &restSubId1)
5692 deleteXapp2Subscription(t, &restSubId2)
5694 waitSubsCleanup(t, e2SubsId1, 10)
5695 waitSubsCleanup(t, e2SubsId2, 10)
5697 mainCtrl.VerifyCounterValues(t)
5698 mainCtrl.VerifyAllClean(t)
5701 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
5702 CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
5704 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5705 Counter{cRestSubReqFromXapp, 2},
5706 Counter{cRestSubRespToXapp, 2},
5707 Counter{cSubReqToE2, 2},
5708 Counter{cSubRespFromE2, 2},
5709 Counter{cRestSubNotifToXapp, 2},
5710 Counter{cRestSubDelReqFromXapp, 2},
5711 Counter{cSubDelReqToE2, 2},
5712 Counter{cSubDelRespFromE2, 2},
5713 Counter{cRestSubDelRespToXapp, 2},
5717 var params *teststube2ap.RESTSubsReqParams = nil
5720 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5721 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5723 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5726 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5727 params.SetMeid("RAN_NAME_1")
5728 params.SetSubActionIDs(int64(2))
5730 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5731 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5732 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5733 xappConn2.ExpectRESTNotification(t, restSubId2)
5734 e2termConn1.SendSubsResp(t, crereq, cremsg)
5735 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5737 deleteXapp1Subscription(t, &restSubId1)
5738 deleteXapp2Subscription(t, &restSubId2)
5740 waitSubsCleanup(t, e2SubsId1, 10)
5741 waitSubsCleanup(t, e2SubsId2, 10)
5743 mainCtrl.VerifyCounterValues(t)
5744 mainCtrl.VerifyAllClean(t)
5747 func TestRESTSubReqDiffActionType(t *testing.T) {
5748 CaseBegin("TestRESTSubReqDiffActionType")
5750 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5751 Counter{cRestSubReqFromXapp, 2},
5752 Counter{cRestSubRespToXapp, 2},
5753 Counter{cSubReqToE2, 2},
5754 Counter{cSubRespFromE2, 2},
5755 Counter{cRestSubNotifToXapp, 2},
5756 Counter{cRestSubDelReqFromXapp, 2},
5757 Counter{cSubDelReqToE2, 2},
5758 Counter{cSubDelRespFromE2, 2},
5759 Counter{cRestSubDelRespToXapp, 2},
5762 const e2Timeout int64 = 2
5763 const e2RetryCount int64 = 2
5764 const routingNeeded bool = true
5767 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5768 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5771 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5772 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5774 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5777 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5778 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5779 params.SetMeid("RAN_NAME_1")
5781 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5782 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5783 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5784 xappConn2.ExpectRESTNotification(t, restSubId2)
5785 e2termConn1.SendSubsResp(t, crereq, cremsg)
5786 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5788 deleteXapp1Subscription(t, &restSubId1)
5789 deleteXapp2Subscription(t, &restSubId2)
5791 waitSubsCleanup(t, e2SubsId1, 10)
5792 waitSubsCleanup(t, e2SubsId2, 10)
5794 mainCtrl.VerifyCounterValues(t)
5795 mainCtrl.VerifyAllClean(t)
5798 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
5799 CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
5801 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5802 Counter{cRestSubReqFromXapp, 2},
5803 Counter{cRestSubRespToXapp, 2},
5804 Counter{cSubReqToE2, 2},
5805 Counter{cSubRespFromE2, 2},
5806 Counter{cRestSubNotifToXapp, 2},
5807 Counter{cRestSubDelReqFromXapp, 2},
5808 Counter{cSubDelReqToE2, 2},
5809 Counter{cSubDelRespFromE2, 2},
5810 Counter{cRestSubDelRespToXapp, 2},
5813 const e2Timeout int64 = 2
5814 const e2RetryCount int64 = 2
5815 const routingNeeded bool = true
5818 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5819 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5822 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5823 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5825 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5828 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
5829 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5830 params.SetMeid("RAN_NAME_1")
5832 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5833 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5834 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5835 xappConn2.ExpectRESTNotification(t, restSubId2)
5836 e2termConn1.SendSubsResp(t, crereq, cremsg)
5837 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5839 deleteXapp1Subscription(t, &restSubId1)
5840 deleteXapp2Subscription(t, &restSubId2)
5842 waitSubsCleanup(t, e2SubsId1, 10)
5843 waitSubsCleanup(t, e2SubsId2, 10)
5845 mainCtrl.VerifyCounterValues(t)
5846 mainCtrl.VerifyAllClean(t)
5849 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
5850 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
5852 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5853 Counter{cRestSubReqFromXapp, 2},
5854 Counter{cRestSubRespToXapp, 2},
5855 Counter{cSubReqToE2, 2},
5856 Counter{cSubRespFromE2, 2},
5857 Counter{cRestSubNotifToXapp, 2},
5858 Counter{cRestSubDelReqFromXapp, 2},
5859 Counter{cSubDelReqToE2, 2},
5860 Counter{cSubDelRespFromE2, 2},
5861 Counter{cRestSubDelRespToXapp, 2},
5865 var params *teststube2ap.RESTSubsReqParams = nil
5868 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5869 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5871 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5874 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5875 params.SetMeid("RAN_NAME_1")
5876 actionDefinition := []int64{5678, 1}
5877 params.SetSubActionDefinition(actionDefinition)
5879 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5880 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5881 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5882 xappConn2.ExpectRESTNotification(t, restSubId2)
5883 e2termConn1.SendSubsResp(t, crereq, cremsg)
5884 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5886 deleteXapp1Subscription(t, &restSubId1)
5887 deleteXapp2Subscription(t, &restSubId2)
5889 waitSubsCleanup(t, e2SubsId1, 10)
5890 waitSubsCleanup(t, e2SubsId2, 10)
5892 mainCtrl.VerifyCounterValues(t)
5893 mainCtrl.VerifyAllClean(t)
5896 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
5897 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
5899 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5900 Counter{cRestSubReqFromXapp, 2},
5901 Counter{cRestSubRespToXapp, 2},
5902 Counter{cSubReqToE2, 2},
5903 Counter{cSubRespFromE2, 2},
5904 Counter{cRestSubNotifToXapp, 2},
5905 Counter{cRestSubDelReqFromXapp, 2},
5906 Counter{cSubDelReqToE2, 2},
5907 Counter{cSubDelRespFromE2, 2},
5908 Counter{cRestSubDelRespToXapp, 2},
5912 var params *teststube2ap.RESTSubsReqParams = nil
5915 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5916 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5918 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5921 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5922 params.SetMeid("RAN_NAME_1")
5923 actionDefinition := []int64{56782}
5924 params.SetSubActionDefinition(actionDefinition)
5926 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5927 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5928 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5929 xappConn2.ExpectRESTNotification(t, restSubId2)
5930 e2termConn1.SendSubsResp(t, crereq, cremsg)
5931 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5933 deleteXapp1Subscription(t, &restSubId1)
5934 deleteXapp2Subscription(t, &restSubId2)
5936 waitSubsCleanup(t, e2SubsId1, 10)
5937 waitSubsCleanup(t, e2SubsId2, 10)
5939 mainCtrl.VerifyCounterValues(t)
5940 mainCtrl.VerifyAllClean(t)
5943 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
5944 CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
5946 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5947 Counter{cRestSubReqFromXapp, 2},
5948 Counter{cRestSubRespToXapp, 2},
5949 Counter{cSubReqToE2, 2},
5950 Counter{cSubRespFromE2, 2},
5951 Counter{cRestSubNotifToXapp, 2},
5952 Counter{cRestSubDelReqFromXapp, 2},
5953 Counter{cSubDelReqToE2, 2},
5954 Counter{cSubDelRespFromE2, 2},
5955 Counter{cRestSubDelRespToXapp, 2},
5959 var params *teststube2ap.RESTSubsReqParams = nil
5962 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5963 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5965 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5968 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5969 params.SetMeid("RAN_NAME_1")
5970 params.SetTimeToWait("w200ms")
5971 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5972 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5973 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5974 xappConn2.ExpectRESTNotification(t, restSubId2)
5975 e2termConn1.SendSubsResp(t, crereq, cremsg)
5976 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5978 deleteXapp1Subscription(t, &restSubId1)
5979 deleteXapp2Subscription(t, &restSubId2)
5981 waitSubsCleanup(t, e2SubsId1, 10)
5982 waitSubsCleanup(t, e2SubsId2, 10)
5984 mainCtrl.VerifyCounterValues(t)
5985 mainCtrl.VerifyAllClean(t)
5988 //-----------------------------------------------------------------------------
5989 // TestRESTUnpackSubscriptionResponseDecodeFail
5992 // +-------+ +---------+ +---------+
5993 // | xapp | | submgr | | e2term |
5994 // +-------+ +---------+ +---------+
5997 // |---------------->| |
5999 // | RESTSubResp | |
6000 // |<----------------| |
6003 // | |------------->|
6005 // | | SubResp | ASN.1 decode fails
6006 // | |<-------------|
6009 // | |------------->|
6011 // | | SubFail | Duplicated action
6012 // | |<-------------|
6013 // | RESTNotif (fail)| |
6014 // |<----------------| |
6017 //-----------------------------------------------------------------------------
6019 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
6020 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
6021 const subReqCount int = 1
6024 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6025 restSubId := xappConn1.SendRESTSubsReq(t, params)
6027 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6028 // Decode of this response fails which will result resending original request
6029 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
6031 _, cremsg = e2termConn1.RecvSubsReq(t)
6033 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6035 // Subscription already created in E2 Node.
6036 fparams := &teststube2ap.E2StubSubsFailParams{}
6038 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6039 e2termConn1.SendSubsFail(t, fparams, cremsg)
6041 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6042 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6044 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6046 // Wait that subs is cleaned
6047 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6049 xappConn1.TestMsgChanEmpty(t)
6050 e2termConn1.TestMsgChanEmpty(t)
6051 mainCtrl.wait_registry_empty(t, 10)
6052 mainCtrl.VerifyAllClean(t)
6055 //-----------------------------------------------------------------------------
6056 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
6059 // +-------+ +---------+ +---------+
6060 // | xapp | | submgr | | e2term |
6061 // +-------+ +---------+ +---------+
6064 // |---------------->| |
6066 // | RESTSubResp | |
6067 // |<----------------| |
6070 // | |------------->|
6072 // | | SubResp | Unknown instanceId
6073 // | |<-------------|
6076 // | |------------->|
6078 // | | SubFail | Duplicated action
6079 // | |<-------------|
6080 // | RESTNotif (fail)| |
6081 // |<----------------| |
6083 // | |------------->|
6086 // | |<-------------|
6088 //-----------------------------------------------------------------------------
6090 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
6091 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
6092 const subReqCount int = 1
6095 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6096 restSubId := xappConn1.SendRESTSubsReq(t, params)
6098 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6100 // Unknown instanceId in this response which will result resending original request
6101 orgInstanceId := crereq.RequestId.InstanceId
6102 crereq.RequestId.InstanceId = 0
6103 e2termConn1.SendSubsResp(t, crereq, cremsg)
6105 _, cremsg = e2termConn1.RecvSubsReq(t)
6107 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6109 // Subscription already created in E2 Node.
6110 fparams := &teststube2ap.E2StubSubsFailParams{}
6112 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6113 e2termConn1.SendSubsFail(t, fparams, cremsg)
6115 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6116 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6118 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6119 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6121 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6123 // Wait that subs is cleaned
6124 mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
6126 xappConn1.TestMsgChanEmpty(t)
6127 e2termConn1.TestMsgChanEmpty(t)
6128 mainCtrl.wait_registry_empty(t, 10)
6129 mainCtrl.VerifyAllClean(t)
6132 //-----------------------------------------------------------------------------
6133 // TestRESTUnpackSubscriptionResponseNoTransaction
6136 // +-------+ +---------+ +---------+
6137 // | xapp | | submgr | | e2term |
6138 // +-------+ +---------+ +---------+
6141 // |---------------->| |
6143 // | RESTSubResp | |
6144 // |<----------------| |
6147 // | |------------->|
6149 // | | SubResp | No transaction for the response
6150 // | |<-------------|
6153 // | |------------->|
6155 // | | SubFail | Duplicated action
6156 // | |<-------------|
6157 // | RESTNotif (fail)| |
6158 // |<----------------| |
6160 // | |------------->|
6163 // | |<-------------|
6166 // | |------------->|
6169 // | |<-------------|
6171 //-----------------------------------------------------------------------------
6172 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
6173 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
6174 const subReqCount int = 1
6177 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6178 restSubId := xappConn1.SendRESTSubsReq(t, params)
6180 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6182 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6183 // No transaction exist for this response which will result resending original request
6184 e2termConn1.SendSubsResp(t, crereq, cremsg)
6186 _, cremsg = e2termConn1.RecvSubsReq(t)
6188 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6190 // Subscription already created in E2 Node.
6191 fparams := &teststube2ap.E2StubSubsFailParams{}
6193 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6194 e2termConn1.SendSubsFail(t, fparams, cremsg)
6196 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6197 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6199 // Resending happens because there no transaction
6200 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6201 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6203 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6204 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6206 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6208 // Wait that subs is cleaned
6209 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6211 xappConn1.TestMsgChanEmpty(t)
6212 e2termConn1.TestMsgChanEmpty(t)
6213 mainCtrl.wait_registry_empty(t, 10)
6214 mainCtrl.VerifyAllClean(t)
6217 //-----------------------------------------------------------------------------
6218 // TestRESTUnpackSubscriptionFailureDecodeFail
6221 // +-------+ +---------+ +---------+
6222 // | xapp | | submgr | | e2term |
6223 // +-------+ +---------+ +---------+
6226 // |---------------->| |
6228 // | RESTSubResp | |
6229 // |<----------------| |
6232 // | |------------->|
6234 // | | SubFail | ASN.1 decode fails
6235 // | |<-------------|
6238 // | |------------->|
6240 // | | SubFail | Duplicated action
6241 // | |<-------------|
6242 // | RESTNotif (fail)| |
6243 // |<----------------| |
6246 //-----------------------------------------------------------------------------
6247 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
6248 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
6249 const subReqCount int = 1
6252 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6253 restSubId := xappConn1.SendRESTSubsReq(t, params)
6255 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6257 // Decode of this response fails which will result resending original request
6258 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
6260 _, cremsg = e2termConn1.RecvSubsReq(t)
6262 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6264 // Subscription already created in E2 Node.
6265 fparams := &teststube2ap.E2StubSubsFailParams{}
6267 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6268 e2termConn1.SendSubsFail(t, fparams, cremsg)
6270 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6271 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6273 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6275 // Wait that subs is cleaned
6276 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6278 xappConn1.TestMsgChanEmpty(t)
6279 e2termConn1.TestMsgChanEmpty(t)
6280 mainCtrl.wait_registry_empty(t, 10)
6281 mainCtrl.VerifyAllClean(t)
6284 //-----------------------------------------------------------------------------
6285 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
6288 // +-------+ +---------+ +---------+
6289 // | xapp | | submgr | | e2term |
6290 // +-------+ +---------+ +---------+
6293 // |---------------->| |
6295 // | RESTSubResp | |
6296 // |<----------------| |
6299 // | |------------->|
6301 // | | SubFail | Unknown instanceId
6302 // | |<-------------|
6305 // | |------------->|
6307 // | | SubFail | Duplicated action
6308 // | |<-------------|
6309 // | RESTNotif (fail)| |
6310 // |<----------------| |
6312 // | |------------->|
6315 // | |<-------------|
6317 //-----------------------------------------------------------------------------
6318 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
6319 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
6320 const subReqCount int = 1
6323 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6324 restSubId := xappConn1.SendRESTSubsReq(t, params)
6326 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6328 // Unknown instanceId in this response which will result resending original request
6329 fparams := &teststube2ap.E2StubSubsFailParams{}
6331 fparams.Fail.RequestId.InstanceId = 0
6332 e2termConn1.SendSubsFail(t, fparams, cremsg)
6334 _, cremsg = e2termConn1.RecvSubsReq(t)
6336 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6338 // Subscription already created in E2 Node.
6339 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6340 e2termConn1.SendSubsFail(t, fparams, cremsg)
6342 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6343 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6345 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6346 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6348 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6350 // Wait that subs is cleaned
6351 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6353 xappConn1.TestMsgChanEmpty(t)
6354 e2termConn1.TestMsgChanEmpty(t)
6355 mainCtrl.wait_registry_empty(t, 10)
6356 mainCtrl.VerifyAllClean(t)
6359 //-----------------------------------------------------------------------------
6360 // TestRESTUnpackSubscriptionFailureNoTransaction
6363 // +-------+ +---------+ +---------+
6364 // | xapp | | submgr | | e2term |
6365 // +-------+ +---------+ +---------+
6368 // |---------------->| |
6370 // | RESTSubResp | |
6371 // |<----------------| |
6374 // | |------------->|
6376 // | | SubFail | No transaction for the response
6377 // | |<-------------|
6380 // | |------------->|
6382 // | | SubFail | Duplicated action
6383 // | |<-------------|
6384 // | RESTNotif (fail)| |
6385 // |<----------------| |
6387 // | |------------->|
6390 // | |<-------------|
6392 //-----------------------------------------------------------------------------
6393 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
6394 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
6395 const subReqCount int = 1
6398 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6399 restSubId := xappConn1.SendRESTSubsReq(t, params)
6401 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6403 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6405 // No transaction exist for this response which will result resending original request
6406 fparams := &teststube2ap.E2StubSubsFailParams{}
6408 e2termConn1.SendSubsFail(t, fparams, cremsg)
6410 _, cremsg = e2termConn1.RecvSubsReq(t)
6412 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6414 // Subscription already created in E2 Node.
6415 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6416 e2termConn1.SendSubsFail(t, fparams, cremsg)
6418 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6419 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6421 // Resending happens because there no transaction
6422 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6423 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6425 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6426 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6428 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6430 // Wait that subs is cleaned
6431 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6433 xappConn1.TestMsgChanEmpty(t)
6434 e2termConn1.TestMsgChanEmpty(t)
6435 mainCtrl.wait_registry_empty(t, 10)
6436 mainCtrl.VerifyAllClean(t)
6439 //-----------------------------------------------------------------------------
6440 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
6443 // +-------+ +---------+ +---------+
6444 // | xapp | | submgr | | e2term |
6445 // +-------+ +---------+ +---------+
6447 // | [SUBS CREATE] |
6450 // | RESTSubDelReq | |
6451 // |---------------->| |
6453 // | RESTSubDelResp | |
6454 // |<----------------| |
6457 // | |------------->|
6459 // | | SubDelResp | ASN.1 decode fails
6460 // | |<-------------|
6463 // | |------------->|
6465 // | | SubDelFail | Subscription does exist any more
6466 // | |<-------------|
6469 //-----------------------------------------------------------------------------
6470 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
6471 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail")
6474 var params *teststube2ap.RESTSubsReqParams = nil
6475 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6478 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6480 // E2t: Receive 1st SubsDelReq
6481 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6483 // Decode of this response fails which will result resending original request
6484 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_REQ)
6486 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6487 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6489 // Subscription does not exist in in E2 Node.
6490 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6492 // Wait that subs is cleaned
6493 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6495 xappConn1.TestMsgChanEmpty(t)
6496 e2termConn1.TestMsgChanEmpty(t)
6497 mainCtrl.wait_registry_empty(t, 10)
6498 mainCtrl.VerifyAllClean(t)
6501 //-----------------------------------------------------------------------------
6502 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
6505 // +-------+ +---------+ +---------+
6506 // | xapp | | submgr | | e2term |
6507 // +-------+ +---------+ +---------+
6509 // | [SUBS CREATE] |
6512 // | RESTSubDelReq | |
6513 // |---------------->| |
6515 // | RESTSubDelResp | |
6516 // |<----------------| |
6519 // | |------------->|
6521 // | | SubDelResp | Unknown instanceId
6522 // | |<-------------|
6525 // | |------------->|
6527 // | | SubDelFail | Subscription does exist any more
6528 // | |<-------------|
6530 //-----------------------------------------------------------------------------
6531 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
6532 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId")
6535 var params *teststube2ap.RESTSubsReqParams = nil
6536 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6539 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6541 // E2t: Receive 1st SubsDelReq
6542 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6544 // Unknown instanceId in this response which will result resending original request
6545 delreq.RequestId.InstanceId = 0
6546 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6548 // E2t: Receive 2nd SubsDelReq
6549 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6551 // Subscription does not exist in in E2 Node.
6552 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6554 // Wait that subs is cleaned
6555 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6557 xappConn1.TestMsgChanEmpty(t)
6558 e2termConn1.TestMsgChanEmpty(t)
6559 mainCtrl.wait_registry_empty(t, 10)
6560 mainCtrl.VerifyAllClean(t)
6563 //-----------------------------------------------------------------------------
6564 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
6567 // +-------+ +---------+ +---------+
6568 // | xapp | | submgr | | e2term |
6569 // +-------+ +---------+ +---------+
6571 // | [SUBS CREATE] |
6574 // | RESTSubDelReq | |
6575 // |---------------->| |
6577 // | RESTSubDelResp | |
6578 // |<----------------| |
6581 // | |------------->|
6583 // | | SubDelResp | No transaction for the response
6584 // | |<-------------|
6587 // | |------------->|
6589 // | | SubDelFail | Subscription does exist any more
6590 // | |<-------------|
6592 //-----------------------------------------------------------------------------
6593 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
6594 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction")
6597 var params *teststube2ap.RESTSubsReqParams = nil
6598 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6601 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6603 // E2t: Receive 1st SubsDelReq
6604 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6606 mainCtrl.MakeTransactionNil(t, e2SubsId)
6608 // No transaction exist for this response which will result resending original request
6609 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6611 // E2t: Receive 2nd SubsDelReq
6612 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6614 // Subscription does not exist in in E2 Node.
6615 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6617 // Wait that subs is cleaned
6618 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6620 xappConn1.TestMsgChanEmpty(t)
6621 e2termConn1.TestMsgChanEmpty(t)
6622 mainCtrl.wait_registry_empty(t, 10)
6623 mainCtrl.VerifyAllClean(t)
6626 //-----------------------------------------------------------------------------
6627 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
6630 // +-------+ +---------+ +---------+
6631 // | xapp | | submgr | | e2term |
6632 // +-------+ +---------+ +---------+
6634 // | [SUBS CREATE] |
6637 // | RESTSubDelReq | |
6638 // |---------------->| |
6640 // | RESTSubDelResp | |
6641 // |<----------------| |
6644 // | |------------->|
6646 // | | SubDelFail | ASN.1 decode fails
6647 // | |<-------------|
6650 // | |------------->|
6652 // | | SubDelFail | Subscription does exist any more
6653 // | |<-------------|
6655 //-----------------------------------------------------------------------------
6656 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
6657 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail")
6660 var params *teststube2ap.RESTSubsReqParams = nil
6661 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6664 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6666 // E2t: Receive 1st SubsDelReq
6667 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6669 // Decode of this response fails which will result resending original request
6670 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
6672 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6673 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6675 // Subscription does not exist in in E2 Node.
6676 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6678 // Wait that subs is cleaned
6679 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6681 xappConn1.TestMsgChanEmpty(t)
6682 e2termConn1.TestMsgChanEmpty(t)
6683 mainCtrl.wait_registry_empty(t, 10)
6684 mainCtrl.VerifyAllClean(t)
6687 //-----------------------------------------------------------------------------
6688 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
6691 // +-------+ +---------+ +---------+
6692 // | xapp | | submgr | | e2term |
6693 // +-------+ +---------+ +---------+
6695 // | [SUBS CREATE] |
6698 // | RESTSubDelReq | |
6699 // |---------------->| |
6701 // | RESTSubDelResp | |
6702 // |<----------------| |
6705 // | |------------->|
6707 // | | SubDelFail | Unknown instanceId
6708 // | |<-------------|
6711 // | |------------->|
6713 // | | SubDelFail | Subscription does exist any more
6714 // | |<-------------|
6716 //-----------------------------------------------------------------------------
6717 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
6718 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId")
6721 var params *teststube2ap.RESTSubsReqParams = nil
6722 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6725 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6727 // E2t: Receive 1st SubsDelReq
6728 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6730 // Unknown instanceId in this response which will result resending original request
6731 delreq.RequestId.InstanceId = 0
6732 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6734 // E2t: Receive 2nd SubsDelReq
6735 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6737 // Subscription does not exist in in E2 Node.
6738 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6740 // Wait that subs is cleaned
6741 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6743 xappConn1.TestMsgChanEmpty(t)
6744 e2termConn1.TestMsgChanEmpty(t)
6745 mainCtrl.wait_registry_empty(t, 10)
6746 mainCtrl.VerifyAllClean(t)
6749 //-----------------------------------------------------------------------------
6750 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
6753 // +-------+ +---------+ +---------+
6754 // | xapp | | submgr | | e2term |
6755 // +-------+ +---------+ +---------+
6757 // | [SUBS CREATE] |
6760 // | RESTSubDelReq | |
6761 // |---------------->| |
6763 // | RESTSubDelResp | |
6764 // |<----------------| |
6767 // | |------------->|
6769 // | | SubDelFail | No transaction for the response
6770 // | |<-------------|
6773 // | |------------->|
6775 // | | SubDelFail | Subscription does exist any more
6776 // | |<-------------|
6778 //-----------------------------------------------------------------------------
6779 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
6780 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction")
6783 var params *teststube2ap.RESTSubsReqParams = nil
6784 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6787 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6789 // E2t: Receive 1st SubsDelReq
6790 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6792 mainCtrl.MakeTransactionNil(t, e2SubsId)
6794 // No transaction exist for this response which will result resending original request
6795 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6797 // E2t: Receive 2nd SubsDelReq
6798 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6800 // Subscription does not exist in in E2 Node.
6801 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6803 // Wait that subs is cleaned
6804 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6806 xappConn1.TestMsgChanEmpty(t)
6807 e2termConn1.TestMsgChanEmpty(t)
6808 mainCtrl.wait_registry_empty(t, 10)
6809 mainCtrl.VerifyAllClean(t)
6812 //-----------------------------------------------------------------------------
6813 // TestRESTSubReqFailAsn1PackSubReqError
6816 // +-------+ +---------+ +---------+
6817 // | xapp | | submgr | | e2term |
6818 // +-------+ +---------+ +---------+
6821 // |---------------->| |
6823 // | RESTSubResp | |
6824 // |<----------------| |
6826 // | ASN.1 encode fails |
6829 // | |------------->|
6832 // | |<-------------|
6836 // |<----------------| |
6838 // | [SUBS DELETE] |
6841 //-----------------------------------------------------------------------------
6842 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
6844 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6845 Counter{cRestSubReqFromXapp, 1},
6846 Counter{cRestSubRespToXapp, 1},
6847 Counter{cRestSubFailNotifToXapp, 1},
6848 Counter{cRestSubDelReqFromXapp, 1},
6849 Counter{cRestSubDelRespToXapp, 1},
6852 const subReqCount int = 1
6854 var params *teststube2ap.RESTSubsReqParams = nil
6855 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
6856 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
6859 restSubId := xappConn1.SendRESTSubsReq(t, params)
6860 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
6862 // E2t: Receive SubsDelReq
6863 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6865 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6866 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
6868 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
6870 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6872 // Wait that subs is cleaned
6873 waitSubsCleanup(t, e2SubsId, 10)
6874 mainCtrl.VerifyCounterValues(t)
6875 mainCtrl.VerifyAllClean(t)
6878 func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
6879 CaseBegin("TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction")
6881 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6882 Counter{cRestSubReqFromXapp, 2},
6883 Counter{cRestSubRespToXapp, 2},
6884 Counter{cSubReqToE2, 2},
6885 Counter{cSubReqTimerExpiry, 1},
6886 Counter{cSubRespFromE2, 1},
6887 Counter{cRestSubNotifToXapp, 1},
6888 Counter{cRestSubFailNotifToXapp, 1},
6889 Counter{cRestSubDelReqFromXapp, 1},
6890 Counter{cSubDelReqToE2, 1},
6891 Counter{cSubDelRespFromE2, 1},
6892 Counter{cRestSubDelRespToXapp, 1},
6895 const e2Timeout int64 = 1
6896 const e2RetryCount int64 = 0
6897 const routingNeeded bool = false
6900 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6901 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6904 restSubId := xappConn1.SendRESTSubsReq(t, params)
6905 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6907 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6908 xappConn1.ExpectRESTNotification(t, restSubId)
6909 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
6910 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6911 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
6914 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6915 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6916 params.SetSubscriptionID(&restSubId)
6917 params.SetTimeToWait("w200ms")
6918 restSubId = xappConn1.SendRESTSubsReq(t, params)
6919 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6921 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
6922 xappConn1.ExpectRESTNotification(t, restSubId)
6923 // SubsResp is missing, e2SubsId will be 0
6924 zeroE2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6925 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", zeroE2SubsId)
6928 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6929 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6930 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6932 waitSubsCleanup(t, e2SubsId, 10)
6934 mainCtrl.VerifyCounterValues(t)
6935 mainCtrl.VerifyAllClean(t)
6938 //-----------------------------------------------------------------------------
6939 // TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle
6942 // +-------+ +---------+ +---------+
6943 // | xapp | | submgr | | e2term |
6944 // +-------+ +---------+ +---------+
6947 // |---------------->| |
6949 // | RESTSubResp | |
6950 // |<----------------| |
6952 // | |------------->|
6955 // | |<-------------|
6958 // |<----------------| |
6961 // |---------------->| |
6963 // | RESTSubResp | |
6964 // |<----------------| |
6966 // | |------------->|
6968 // | Submgr restart |
6970 // | RESTSubDelReq | |
6971 // |---------------->| |
6974 // | |------------->|
6977 // | |<-------------|
6979 // | RESTSubDelResp | |
6980 // |<----------------| |
6982 //-----------------------------------------------------------------------------
6984 func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
6985 CaseBegin("TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle")
6987 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6988 Counter{cRestSubReqFromXapp, 2},
6989 Counter{cRestSubRespToXapp, 2},
6990 Counter{cSubReqToE2, 2},
6991 Counter{cSubRespFromE2, 1},
6992 Counter{cRestSubNotifToXapp, 1},
6993 Counter{cRestSubDelReqFromXapp, 1},
6994 Counter{cSubDelReqToE2, 1},
6995 Counter{cSubDelRespFromE2, 1},
6996 Counter{cRestSubDelRespToXapp, 1},
6999 const e2Timeout int64 = 1
7000 const e2RetryCount int64 = 0
7001 const routingNeeded bool = false
7004 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7005 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7006 // Create subscription
7007 restSubId := xappConn1.SendRESTSubsReq(t, params)
7008 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
7010 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7011 xappConn1.ExpectRESTNotification(t, restSubId)
7012 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
7013 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7014 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7016 // Check subscription
7017 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
7020 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7021 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7022 params.SetSubscriptionID(&restSubId)
7023 params.SetTimeToWait("w200ms")
7024 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
7025 restSubId = xappConn1.SendRESTSubsReq(t, params)
7026 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
7028 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
7029 mainCtrl.SetResetTestFlag(t, false)
7031 // SubsResp is missing due to submgr restart
7033 mainCtrl.SimulateRestart(t)
7034 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
7036 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
7037 // That needs to be completed before successful subscription query is possible
7038 <-time.After(time.Second * 1)
7040 // Check subscription
7041 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
7043 // Delete subscription
7044 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7045 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7046 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7048 //Wait that subs is cleaned
7049 waitSubsCleanup(t, e2SubsId, 10)
7051 mainCtrl.VerifyCounterValues(t)
7052 mainCtrl.VerifyAllClean(t)
7055 ////////////////////////////////////////////////////////////////////////////////////
7056 // Services for UT cases
7057 ////////////////////////////////////////////////////////////////////////////////////
7058 const subReqCount int = 1
7059 const host string = "localhost"
7061 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
7063 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
7065 restSubId := fromXappConn.SendRESTSubsReq(t, params)
7066 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
7068 crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
7069 fromXappConn.ExpectRESTNotification(t, restSubId)
7070 toE2termConn.SendSubsResp(t, crereq1, cremsg1)
7071 e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
7072 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7074 return restSubId, e2SubsId
7077 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
7079 params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
7081 params.SetMeid(meid)
7083 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
7084 restSubId := xappConn2.SendRESTSubsReq(t, params)
7085 xappConn2.ExpectRESTNotification(t, restSubId)
7086 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
7087 e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
7088 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7090 return restSubId, e2SubsId
7093 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
7095 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7096 restSubId := xappConn1.SendRESTSubsReq(t, params)
7097 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
7099 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7100 xappConn1.ExpectRESTNotification(t, restSubId)
7101 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
7102 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7103 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7105 return restSubId, e2SubsId
7108 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
7109 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7110 restSubId := xappConn1.SendRESTSubsReq(t, params)
7112 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7113 fparams1 := &teststube2ap.E2StubSubsFailParams{}
7114 fparams1.Set(crereq1)
7115 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
7117 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
7118 xappConn1.ExpectRESTNotification(t, restSubId)
7119 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
7120 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7121 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
7123 return restSubId, e2SubsId
7126 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
7127 fromXappConn.SendRESTSubsDelReq(t, restSubId)
7128 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
7129 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
7132 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
7133 xappConn1.SendRESTSubsDelReq(t, restSubId)
7134 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7135 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7138 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
7139 xappConn2.SendRESTSubsDelReq(t, restSubId)
7140 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7141 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7144 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
7145 resp, _ := xapp.Subscription.QuerySubscriptions()
7146 assert.Equal(t, e2SubsId, resp[0].SubscriptionID)
7147 assert.Equal(t, meid, resp[0].Meid)
7148 assert.Equal(t, endpoint, resp[0].ClientEndpoint)
7151 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
7152 //Wait that subs is cleaned
7153 mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
7155 xappConn1.TestMsgChanEmpty(t)
7156 xappConn2.TestMsgChanEmpty(t)
7157 e2termConn1.TestMsgChanEmpty(t)
7158 mainCtrl.wait_registry_empty(t, timeout)
7161 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
7163 var e2SubsId []uint32
7165 for i := 0; i < count; i++ {
7166 xapp.Logger.Debug("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
7167 crereq, cremsg := toE2termConn.RecvSubsReq(t)
7168 fromXappConn.ExpectRESTNotification(t, restSubId)
7169 toE2termConn.SendSubsResp(t, crereq, cremsg)
7170 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
7171 e2SubsId = append(e2SubsId, instanceId)
7172 xapp.Logger.Debug("TEST: %v", e2SubsId)
7173 xapp.Logger.Debug("TEST: %d ===================================== END CRE ============================================", i+1)
7174 <-time.After(100 * time.Millisecond)
7179 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
7181 for i := 0; i < len(e2SubsIds); i++ {
7182 xapp.Logger.Debug("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
7183 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
7184 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
7185 <-time.After(1 * time.Second)
7186 xapp.Logger.Debug("TEST: %d ===================================== END DEL ============================================", i+1)
7187 <-time.After(100 * time.Millisecond)
7190 // Wait that subs is cleaned
7191 for i := 0; i < len(e2SubsIds); i++ {
7192 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)