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 ==================================================================================
26 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
27 "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststube2ap"
28 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
29 "github.com/stretchr/testify/assert"
32 //-----------------------------------------------------------------------------
33 // TestSubReqAndRouteNok
36 // +-------+ +---------+ +---------+
37 // | xapp | | submgr | | rtmgr |
38 // +-------+ +---------+ +---------+
50 // | [SUBS INT DELETE] |
53 //-----------------------------------------------------------------------------
55 func TestSubReqAndRouteNok(t *testing.T) {
56 CaseBegin("TestSubReqAndRouteNok")
59 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
60 Counter{cSubReqFromXapp, 1},
61 Counter{cRouteCreateFail, 1},
64 waiter := rtmgrHttp.AllocNextEvent(false)
65 newSubsId := mainCtrl.get_registry_next_subid(t)
66 xappConn1.SendSubsReq(t, nil, nil)
69 //Wait that subs is cleaned
70 mainCtrl.wait_subs_clean(t, newSubsId, 10)
72 xappConn1.TestMsgChanEmpty(t)
73 xappConn2.TestMsgChanEmpty(t)
74 e2termConn1.TestMsgChanEmpty(t)
75 mainCtrl.wait_registry_empty(t, 10)
77 <-time.After(1 * time.Second)
78 mainCtrl.VerifyCounterValues(t)
81 //-----------------------------------------------------------------------------
82 // TestSubReqAndRouteUpdateNok
85 // +-------+ +-------+ +---------+ +---------+
86 // | xapp2 | | xapp1 | | submgr | | rtmgr |
87 // +-------+ +-------+ +---------+ +---------+
89 // | [SUBS CREATE] | |
93 // | SubReq (mergeable) | |
94 // |--------------------------->| | |
96 // | | | RouteUpdate |
97 // | | |------------->|
99 // | | | RouteUpdate |
100 // | | | status:400 |
101 // | | |<-------------|
103 // | [SUBS INT DELETE] | |
106 // | [SUBS DELETE] | |
109 func TestSubReqAndRouteUpdateNok(t *testing.T) {
110 CaseBegin("TestSubReqAndRouteUpdateNok")
112 // Init counter check
113 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
114 Counter{cSubReqFromXapp, 2},
115 Counter{cSubReqToE2, 1},
116 Counter{cSubRespFromE2, 1},
117 Counter{cSubRespToXapp, 1},
118 Counter{cRouteCreateUpdateFail, 1},
119 Counter{cSubDelReqFromXapp, 1},
120 Counter{cSubDelReqToE2, 1},
121 Counter{cSubDelRespFromE2, 1},
122 Counter{cSubDelRespToXapp, 1},
125 cretrans := xappConn1.SendSubsReq(t, nil, nil)
126 crereq, cremsg := e2termConn1.RecvSubsReq(t)
127 e2termConn1.SendSubsResp(t, crereq, cremsg)
128 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
130 resp, _ := xapp.Subscription.QuerySubscriptions()
131 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
132 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
133 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
135 waiter := rtmgrHttp.AllocNextEvent(false)
136 newSubsId := mainCtrl.get_registry_next_subid(t)
137 xappConn2.SendSubsReq(t, nil, nil)
140 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
141 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
143 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
144 xappConn1.RecvSubsDelResp(t, deltrans)
146 //Wait that subs is cleaned
147 mainCtrl.wait_subs_clean(t, newSubsId, 10)
148 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
150 xappConn1.TestMsgChanEmpty(t)
151 xappConn2.TestMsgChanEmpty(t)
152 e2termConn1.TestMsgChanEmpty(t)
153 mainCtrl.wait_registry_empty(t, 10)
155 mainCtrl.VerifyCounterValues(t)
158 //-----------------------------------------------------------------------------
159 // TestSubDelReqAndRouteDeleteNok
162 // +-------+ +---------+ +---------+ +---------+
163 // | xapp | | submgr | | e2term | | rtmgr |
164 // +-------+ +---------+ +---------+ +---------+
166 // | [SUBS CREATE] | |
171 // |------------->| | |
173 // | |------------->| |
175 // | |<-------------| |
177 // |<-------------| | |
178 // | | RouteDelete | |
179 // | |---------------------------->|
181 // | | RouteDelete | |
182 // | | status:400 | |
183 // | |<----------------------------|
185 func TestSubDelReqAndRouteDeleteNok(t *testing.T) {
186 CaseBegin("TestSubDelReqAndRouteDeleteNok")
188 // Init counter check
189 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
190 Counter{cSubReqFromXapp, 1},
191 Counter{cSubReqToE2, 1},
192 Counter{cSubRespFromE2, 1},
193 Counter{cSubRespToXapp, 1},
194 Counter{cSubDelReqFromXapp, 1},
195 Counter{cRouteDeleteFail, 1},
196 Counter{cSubDelReqToE2, 1},
197 Counter{cSubDelRespFromE2, 1},
198 Counter{cSubDelRespToXapp, 1},
201 cretrans := xappConn1.SendSubsReq(t, nil, nil)
202 crereq, cremsg := e2termConn1.RecvSubsReq(t)
203 e2termConn1.SendSubsResp(t, crereq, cremsg)
204 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
206 resp, _ := xapp.Subscription.QuerySubscriptions()
207 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
208 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
209 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
211 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
212 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
214 waiter := rtmgrHttp.AllocNextEvent(false)
215 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
218 xappConn1.RecvSubsDelResp(t, deltrans)
220 //Wait that subs is cleaned
221 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
223 xappConn1.TestMsgChanEmpty(t)
224 xappConn2.TestMsgChanEmpty(t)
225 e2termConn1.TestMsgChanEmpty(t)
226 mainCtrl.wait_registry_empty(t, 10)
228 mainCtrl.VerifyCounterValues(t)
231 //-----------------------------------------------------------------------------
232 // TestSubMergeDelAndRouteUpdateNok
234 // +-------+ +-------+ +---------+ +---------+
235 // | xapp2 | | xapp1 | | submgr | | e2term |
236 // +-------+ +-------+ +---------+ +---------+
241 // | |------------->| |
244 // | | |------------->|
246 // | | |<-------------|
248 // | |<-------------| |
251 // |--------------------------->| |
254 // |<---------------------------| |
256 // | | SubDelReq 1 | |
257 // | |------------->| |
258 // | | | RouteUpdate |
259 // | | |-----> rtmgr |
261 // | | | RouteUpdate |
262 // | | | status:400 |
263 // | | |<----- rtmgr |
265 // | | SubDelResp 1 | |
266 // | |<-------------| |
269 // |--------------------------->| |
271 // | | | SubDelReq 2 |
272 // | | |------------->|
274 // | | | SubDelReq 2 |
275 // | | |------------->|
277 // | SubDelResp 2 | |
278 // |<---------------------------| |
280 //-----------------------------------------------------------------------------
281 func TestSubMergeDelAndRouteUpdateNok(t *testing.T) {
282 CaseBegin("TestSubMergeDelAndRouteUpdateNok")
284 // Init counter check
285 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
286 Counter{cSubReqFromXapp, 2},
287 Counter{cSubReqToE2, 1},
288 Counter{cSubRespFromE2, 1},
289 Counter{cSubRespToXapp, 2},
290 Counter{cSubDelReqFromXapp, 2},
291 Counter{cRouteDeleteUpdateFail, 1},
292 Counter{cSubDelReqToE2, 1},
293 Counter{cSubDelRespFromE2, 1},
294 Counter{cSubDelRespToXapp, 2},
298 rparams1 := &teststube2ap.E2StubSubsReqParams{}
300 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
301 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
302 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
303 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
306 rparams2 := &teststube2ap.E2StubSubsReqParams{}
308 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
309 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
311 resp, _ := xapp.Subscription.QuerySubscriptions()
312 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
313 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
314 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
317 waiter := rtmgrHttp.AllocNextEvent(false)
318 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
321 xappConn1.RecvSubsDelResp(t, deltrans1)
324 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
325 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
326 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
327 xappConn2.RecvSubsDelResp(t, deltrans2)
328 //Wait that subs is cleaned
329 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
331 xappConn1.TestMsgChanEmpty(t)
332 xappConn2.TestMsgChanEmpty(t)
333 e2termConn1.TestMsgChanEmpty(t)
334 mainCtrl.wait_registry_empty(t, 10)
336 mainCtrl.VerifyCounterValues(t)
339 //-----------------------------------------------------------------------------
341 //-----------------------------------------------------------------------------
342 // TestSubReqAndSubDelOk
345 // +-------+ +---------+ +---------+
346 // | xapp | | submgr | | e2term |
347 // +-------+ +---------+ +---------+
350 // |------------->| |
353 // | |------------->|
356 // | |<-------------|
359 // |<-------------| |
363 // |------------->| |
366 // | |------------->|
369 // | |<-------------|
372 // |<-------------| |
374 //-----------------------------------------------------------------------------
375 func TestSubReqAndSubDelOk(t *testing.T) {
376 CaseBegin("TestSubReqAndSubDelOk")
378 // Init counter check
379 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
380 Counter{cSubReqFromXapp, 1},
381 Counter{cSubReqToE2, 1},
382 Counter{cSubRespFromE2, 1},
383 Counter{cSubRespToXapp, 1},
384 Counter{cSubDelReqFromXapp, 1},
385 Counter{cSubDelReqToE2, 1},
386 Counter{cSubDelRespFromE2, 1},
387 Counter{cSubDelRespToXapp, 1},
390 cretrans := xappConn1.SendSubsReq(t, nil, nil)
391 crereq, cremsg := e2termConn1.RecvSubsReq(t)
392 e2termConn1.SendSubsResp(t, crereq, cremsg)
393 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
395 resp, _ := xapp.Subscription.QuerySubscriptions()
396 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
397 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
398 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
400 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
401 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
403 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
404 xappConn1.RecvSubsDelResp(t, deltrans)
406 //Wait that subs is cleaned
407 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
409 xappConn1.TestMsgChanEmpty(t)
410 xappConn2.TestMsgChanEmpty(t)
411 e2termConn1.TestMsgChanEmpty(t)
412 mainCtrl.wait_registry_empty(t, 10)
414 mainCtrl.VerifyCounterValues(t)
417 //-----------------------------------------------------------------------------
418 // TestSubReqRetransmission
421 // +-------+ +---------+ +---------+
422 // | xapp | | submgr | | e2term |
423 // +-------+ +---------+ +---------+
426 // |------------->| |
429 // | |------------->|
433 // |------------->| |
436 // | |<-------------|
439 // |<-------------| |
444 //-----------------------------------------------------------------------------
445 func TestSubReqRetransmission(t *testing.T) {
446 CaseBegin("TestSubReqRetransmission")
449 cretrans := xappConn1.SendSubsReq(t, nil, nil)
450 crereq, cremsg := e2termConn1.RecvSubsReq(t)
452 seqBef := mainCtrl.get_msgcounter(t)
453 xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq
454 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
456 // hack as there is no real way to see has message be handled.
457 // Previuos counter check just tells that is has been received by submgr
458 // --> artificial delay
459 <-time.After(1 * time.Second)
460 e2termConn1.SendSubsResp(t, crereq, cremsg)
461 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
464 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
465 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
466 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
467 xappConn1.RecvSubsDelResp(t, deltrans)
469 //Wait that subs is cleaned
470 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
472 xappConn1.TestMsgChanEmpty(t)
473 xappConn2.TestMsgChanEmpty(t)
474 e2termConn1.TestMsgChanEmpty(t)
475 mainCtrl.wait_registry_empty(t, 10)
478 //-----------------------------------------------------------------------------
479 // TestSubDelReqRetransmission
482 // +-------+ +---------+ +---------+
483 // | xapp | | submgr | | e2term |
484 // +-------+ +---------+ +---------+
490 // |------------->| |
493 // | |------------->|
498 // |------------->| |
501 // | |<-------------|
504 // |<-------------| |
506 //-----------------------------------------------------------------------------
507 func TestSubDelReqRetransmission(t *testing.T) {
508 CaseBegin("TestSubDelReqRetransmission")
511 cretrans := xappConn1.SendSubsReq(t, nil, nil)
512 crereq, cremsg := e2termConn1.RecvSubsReq(t)
513 e2termConn1.SendSubsResp(t, crereq, cremsg)
514 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
517 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
518 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
520 seqBef := mainCtrl.get_msgcounter(t)
521 xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq
522 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
524 // hack as there is no real way to see has message be handled.
525 // Previuos counter check just tells that is has been received by submgr
526 // --> artificial delay
527 <-time.After(1 * time.Second)
529 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
530 xappConn1.RecvSubsDelResp(t, deltrans)
532 //Wait that subs is cleaned
533 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
535 xappConn1.TestMsgChanEmpty(t)
536 xappConn2.TestMsgChanEmpty(t)
537 e2termConn1.TestMsgChanEmpty(t)
538 mainCtrl.wait_registry_empty(t, 10)
541 //-----------------------------------------------------------------------------
542 // TestSubDelReqCollision
545 // +-------+ +---------+ +---------+
546 // | xapp | | submgr | | e2term |
547 // +-------+ +---------+ +---------+
553 // |------------->| |
556 // | |------------->|
561 // |------------->| |
563 // | | SubDelResp 1 |
564 // | |<-------------|
566 // | SubDelResp 1 | |
567 // |<-------------| |
569 // | SubDelResp 2 | |
570 // |<-------------| |
572 //-----------------------------------------------------------------------------
574 func TestSubDelReqCollision(t *testing.T) {
575 CaseBegin("TestSubDelReqCollision")
578 cretrans := xappConn1.SendSubsReq(t, nil, nil)
579 crereq, cremsg := e2termConn1.RecvSubsReq(t)
580 e2termConn1.SendSubsResp(t, crereq, cremsg)
581 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
584 xappConn1.SendSubsDelReq(t, nil, e2SubsId)
585 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
587 // Subs Delete colliding
588 seqBef := mainCtrl.get_msgcounter(t)
589 deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
590 xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq
591 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
593 // hack as there is no real way to see has message be handled.
594 // Previuos counter check just tells that is has been received by submgr
595 // --> artificial delay
596 <-time.After(1 * time.Second)
598 // Del resp for first and second
599 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
601 // don't care in which order responses are received
602 xappConn1.RecvSubsDelResp(t, nil)
603 xappConn1.RecvSubsDelResp(t, nil)
605 //Wait that subs is cleaned
606 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
608 xappConn1.TestMsgChanEmpty(t)
609 xappConn2.TestMsgChanEmpty(t)
610 e2termConn1.TestMsgChanEmpty(t)
611 mainCtrl.wait_registry_empty(t, 10)
614 //-----------------------------------------------------------------------------
615 // TestSubReqAndSubDelOkTwoParallel
618 // +-------+ +-------+ +---------+ +---------+
619 // | xapp | | xapp | | submgr | | e2term |
620 // +-------+ +-------+ +---------+ +---------+
625 // | |------------->| |
628 // | | |------------->|
631 // |------------------------>| |
634 // | | |------------->|
637 // | | |<-------------|
639 // | |<-------------| |
642 // | | |<-------------|
644 // |<------------------------| |
646 // | | [SUBS 1 DELETE] |
648 // | | [SUBS 2 DELETE] |
651 //-----------------------------------------------------------------------------
653 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
654 CaseBegin("TestSubReqAndSubDelOkTwoParallel")
657 rparams1 := &teststube2ap.E2StubSubsReqParams{}
659 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
660 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
663 rparams2 := &teststube2ap.E2StubSubsReqParams{}
666 rparams2.Req.EventTriggerDefinition.Data.Length = 1
667 rparams2.Req.EventTriggerDefinition.Data.Data = make([]uint8, rparams2.Req.EventTriggerDefinition.Data.Length)
668 rparams2.Req.EventTriggerDefinition.Data.Data[0] = 2
670 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
671 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
674 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
675 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
678 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
679 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
682 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
683 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
684 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
685 xappConn1.RecvSubsDelResp(t, deltrans1)
686 //Wait that subs is cleaned
687 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
690 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
691 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
692 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
693 xappConn2.RecvSubsDelResp(t, deltrans2)
694 //Wait that subs is cleaned
695 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
697 xappConn1.TestMsgChanEmpty(t)
698 xappConn2.TestMsgChanEmpty(t)
699 e2termConn1.TestMsgChanEmpty(t)
700 mainCtrl.wait_registry_empty(t, 10)
703 //-----------------------------------------------------------------------------
704 // TestSameSubsDiffRan
705 // Same subscription to different RANs
708 // +-------+ +---------+ +---------+
709 // | xapp | | submgr | | e2term |
710 // +-------+ +---------+ +---------+
715 // |------------->| |
718 // | |------------->|
721 // | |<-------------|
724 // |<-------------| |
727 // |------------->| |
730 // | |------------->|
733 // | |<-------------|
736 // |<-------------| |
738 // | [SUBS r1 DELETE] |
740 // | [SUBS r2 DELETE] |
743 //-----------------------------------------------------------------------------
744 func TestSameSubsDiffRan(t *testing.T) {
745 CaseBegin("TestSameSubsDiffRan")
748 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
749 xappConn1.SendSubsReq(t, nil, cretrans1)
750 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
751 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
752 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
755 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
756 xappConn1.SendSubsReq(t, nil, cretrans2)
757 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
758 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
759 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
762 deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
763 xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
764 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
765 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
766 xappConn1.RecvSubsDelResp(t, deltrans1)
767 //Wait that subs is cleaned
768 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
771 deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
772 xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
773 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
774 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
775 xappConn1.RecvSubsDelResp(t, deltrans2)
776 //Wait that subs is cleaned
777 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
779 xappConn1.TestMsgChanEmpty(t)
780 xappConn2.TestMsgChanEmpty(t)
781 e2termConn1.TestMsgChanEmpty(t)
782 mainCtrl.wait_registry_empty(t, 10)
785 //-----------------------------------------------------------------------------
786 // TestSubReqRetryInSubmgr
789 // +-------+ +---------+ +---------+
790 // | xapp | | submgr | | e2term |
791 // +-------+ +---------+ +---------+
794 // |------------->| |
797 // | |------------->|
801 // | |------------->|
804 // | |<-------------|
807 // |<-------------| |
812 //-----------------------------------------------------------------------------
814 func TestSubReqRetryInSubmgr(t *testing.T) {
815 CaseBegin("TestSubReqRetryInSubmgr start")
817 // Init counter check
818 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
819 Counter{cSubReqFromXapp, 1},
820 Counter{cSubReqToE2, 1},
821 Counter{cSubReReqToE2, 1},
822 Counter{cSubRespFromE2, 1},
823 Counter{cSubRespToXapp, 1},
824 Counter{cSubDelReqFromXapp, 1},
825 Counter{cSubDelReqToE2, 1},
826 Counter{cSubDelRespFromE2, 1},
827 Counter{cSubDelRespToXapp, 1},
830 // Xapp: Send SubsReq
831 cretrans := xappConn1.SendSubsReq(t, nil, nil)
833 // E2t: Receive 1st SubsReq
834 e2termConn1.RecvSubsReq(t)
836 // E2t: Receive 2nd SubsReq and send SubsResp
837 crereq, cremsg := e2termConn1.RecvSubsReq(t)
838 e2termConn1.SendSubsResp(t, crereq, cremsg)
840 // Xapp: Receive SubsResp
841 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
843 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
844 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
845 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
846 xappConn1.RecvSubsDelResp(t, deltrans)
848 // Wait that subs is cleaned
849 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
851 xappConn1.TestMsgChanEmpty(t)
852 xappConn2.TestMsgChanEmpty(t)
853 e2termConn1.TestMsgChanEmpty(t)
854 mainCtrl.wait_registry_empty(t, 10)
856 mainCtrl.VerifyCounterValues(t)
859 //-----------------------------------------------------------------------------
860 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
863 // +-------+ +---------+ +---------+
864 // | xapp | | submgr | | e2term |
865 // +-------+ +---------+ +---------+
868 // |------------->| |
871 // | |------------->|
875 // | |------------->|
878 // | |------------->|
881 // | |<-------------|
884 //-----------------------------------------------------------------------------
885 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
886 CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
888 // Init counter check
889 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
890 Counter{cSubReqFromXapp, 1},
891 Counter{cSubReqToE2, 1},
892 Counter{cSubReReqToE2, 1},
893 Counter{cSubReqTimerExpiry, 2},
894 Counter{cSubDelReqToE2, 1},
895 Counter{cSubDelRespFromE2, 1},
898 // Xapp: Send SubsReq
899 xappConn1.SendSubsReq(t, nil, nil)
901 // E2t: Receive 1st SubsReq
902 e2termConn1.RecvSubsReq(t)
904 // E2t: Receive 2nd SubsReq
905 e2termConn1.RecvSubsReq(t)
907 // E2t: Send receive SubsDelReq and send SubsResp
908 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
909 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
911 // Wait that subs is cleaned
912 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 10)
914 xappConn1.TestMsgChanEmpty(t)
915 xappConn2.TestMsgChanEmpty(t)
916 e2termConn1.TestMsgChanEmpty(t)
917 mainCtrl.wait_registry_empty(t, 10)
919 mainCtrl.VerifyCounterValues(t)
922 //-----------------------------------------------------------------------------
923 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
926 // +-------+ +---------+ +---------+
927 // | xapp | | submgr | | e2term |
928 // +-------+ +---------+ +---------+
931 // |------------->| |
934 // | |------------->|
938 // | |------------->|
941 // | |------------->|
945 // | |------------->|
949 //-----------------------------------------------------------------------------
951 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
952 CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
954 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
955 Counter{cSubReqFromXapp, 1},
956 Counter{cSubReqToE2, 1},
957 Counter{cSubReReqToE2, 1},
958 Counter{cSubReqTimerExpiry, 2},
959 Counter{cSubDelReqToE2, 1},
960 Counter{cSubDelReReqToE2, 1},
961 Counter{cSubDelReqTimerExpiry, 2},
964 // Xapp: Send SubsReq
965 xappConn1.SendSubsReq(t, nil, nil)
967 // E2t: Receive 1st SubsReq
968 e2termConn1.RecvSubsReq(t)
970 // E2t: Receive 2nd SubsReq
971 e2termConn1.RecvSubsReq(t)
973 // E2t: Receive 1st SubsDelReq
974 e2termConn1.RecvSubsDelReq(t)
976 // E2t: Receive 2nd SubsDelReq
977 delreq, _ := e2termConn1.RecvSubsDelReq(t)
979 // Wait that subs is cleaned
980 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 15)
982 xappConn1.TestMsgChanEmpty(t)
983 xappConn2.TestMsgChanEmpty(t)
984 e2termConn1.TestMsgChanEmpty(t)
985 mainCtrl.wait_registry_empty(t, 10)
987 mainCtrl.VerifyCounterValues(t)
990 //-----------------------------------------------------------------------------
991 // TestSubReqSubFailRespInSubmgr
994 // +-------+ +---------+ +---------+
995 // | xapp | | submgr | | e2term |
996 // +-------+ +---------+ +---------+
999 // |------------->| |
1002 // | |------------->|
1005 // | |<-------------|
1008 // | |------------->|
1011 // | |<-------------|
1014 // |<-------------| |
1017 //-----------------------------------------------------------------------------
1019 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1020 CaseBegin("TestSubReqSubFailRespInSubmgr start")
1022 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1023 Counter{cSubReqFromXapp, 1},
1024 Counter{cSubReqToE2, 1},
1025 Counter{cSubFailFromE2, 1},
1026 Counter{cSubFailToXapp, 1},
1029 // Xapp: Send SubsReq
1030 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1032 // E2t: Receive SubsReq and send SubsFail (first)
1033 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1034 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1035 fparams1.Set(crereq1)
1036 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1038 // E2t: Receive SubsDelReq and send SubsDelResp (internal first)
1039 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1040 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1042 // Xapp: Receive SubsFail
1043 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
1045 // Wait that subs is cleaned
1046 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1048 xappConn1.TestMsgChanEmpty(t)
1049 xappConn2.TestMsgChanEmpty(t)
1050 e2termConn1.TestMsgChanEmpty(t)
1051 mainCtrl.wait_registry_empty(t, 10)
1053 mainCtrl.VerifyCounterValues(t)
1056 //-----------------------------------------------------------------------------
1057 // TestSubDelReqRetryInSubmgr
1060 // +-------+ +---------+ +---------+
1061 // | xapp | | submgr | | e2term |
1062 // +-------+ +---------+ +---------+
1064 // | [SUBS CREATE] |
1068 // |------------->| |
1071 // | |------------->|
1074 // | |------------->|
1077 // | |<-------------|
1080 // |<-------------| |
1082 //-----------------------------------------------------------------------------
1084 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1086 CaseBegin("TestSubDelReqRetryInSubmgr start")
1089 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1090 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1091 e2termConn1.SendSubsResp(t, crereq, cremsg)
1092 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1095 // Xapp: Send SubsDelReq
1096 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1098 // E2t: Receive 1st SubsDelReq
1099 e2termConn1.RecvSubsDelReq(t)
1101 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1102 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1103 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1105 // Xapp: Receive SubsDelResp
1106 xappConn1.RecvSubsDelResp(t, deltrans)
1108 // Wait that subs is cleaned
1109 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1111 xappConn1.TestMsgChanEmpty(t)
1112 xappConn2.TestMsgChanEmpty(t)
1113 e2termConn1.TestMsgChanEmpty(t)
1114 mainCtrl.wait_registry_empty(t, 10)
1117 //-----------------------------------------------------------------------------
1118 // TestSubDelReqTwoRetriesNoRespInSubmgr
1121 // +-------+ +---------+ +---------+
1122 // | xapp | | submgr | | e2term |
1123 // +-------+ +---------+ +---------+
1125 // | [SUBS CREATE] |
1129 // |------------->| |
1132 // | |------------->|
1135 // | |------------->|
1139 // |<-------------| |
1141 //-----------------------------------------------------------------------------
1143 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1145 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
1148 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1149 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1150 e2termConn1.SendSubsResp(t, crereq, cremsg)
1151 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1154 // Xapp: Send SubsDelReq
1155 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1157 // E2t: Receive 1st SubsDelReq
1158 e2termConn1.RecvSubsDelReq(t)
1160 // E2t: Receive 2nd SubsDelReq
1161 e2termConn1.RecvSubsDelReq(t)
1163 // Xapp: Receive SubsDelResp
1164 xappConn1.RecvSubsDelResp(t, deltrans)
1166 // Wait that subs is cleaned
1167 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1169 xappConn1.TestMsgChanEmpty(t)
1170 xappConn2.TestMsgChanEmpty(t)
1171 e2termConn1.TestMsgChanEmpty(t)
1172 mainCtrl.wait_registry_empty(t, 10)
1175 //-----------------------------------------------------------------------------
1176 // TestSubDelReqSubDelFailRespInSubmgr
1179 // +-------+ +---------+ +---------+
1180 // | xapp | | submgr | | e2term |
1181 // +-------+ +---------+ +---------+
1183 // | [SUBS CREATE] |
1187 // |------------->| |
1190 // | |------------->|
1193 // | |<-------------|
1196 // |<-------------| |
1199 //-----------------------------------------------------------------------------
1201 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1202 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1204 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1205 Counter{cSubReqFromXapp, 1},
1206 Counter{cSubReqToE2, 1},
1207 Counter{cSubRespFromE2, 1},
1208 Counter{cSubRespToXapp, 1},
1209 Counter{cSubDelReqFromXapp, 1},
1210 Counter{cSubDelReqToE2, 1},
1211 Counter{cSubDelFailFromE2, 1},
1212 Counter{cSubDelRespToXapp, 1},
1216 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1217 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1218 e2termConn1.SendSubsResp(t, crereq, cremsg)
1219 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1221 // Xapp: Send SubsDelReq
1222 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1224 // E2t: Send receive SubsDelReq and send SubsDelFail
1225 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1226 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1228 // Xapp: Receive SubsDelResp
1229 xappConn1.RecvSubsDelResp(t, deltrans)
1231 // Wait that subs is cleaned
1232 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1234 xappConn1.TestMsgChanEmpty(t)
1235 xappConn2.TestMsgChanEmpty(t)
1236 e2termConn1.TestMsgChanEmpty(t)
1237 mainCtrl.wait_registry_empty(t, 10)
1239 mainCtrl.VerifyCounterValues(t)
1242 //-----------------------------------------------------------------------------
1243 // TestSubReqAndSubDelOkSameAction
1246 // +-------+ +-------+ +---------+ +---------+
1247 // | xapp2 | | xapp1 | | submgr | | e2term |
1248 // +-------+ +-------+ +---------+ +---------+
1253 // | |------------->| |
1256 // | | |------------->|
1258 // | | |<-------------|
1260 // | |<-------------| |
1263 // |--------------------------->| |
1266 // |<---------------------------| |
1268 // | | SubDelReq 1 | |
1269 // | |------------->| |
1271 // | | SubDelResp 1 | |
1272 // | |<-------------| |
1274 // | SubDelReq 2 | |
1275 // |--------------------------->| |
1277 // | | | SubDelReq 2 |
1278 // | | |------------->|
1280 // | | | SubDelReq 2 |
1281 // | | |------------->|
1283 // | SubDelResp 2 | |
1284 // |<---------------------------| |
1286 //-----------------------------------------------------------------------------
1287 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
1288 CaseBegin("TestSubReqAndSubDelOkSameAction")
1290 // Init counter check
1291 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1292 Counter{cSubReqFromXapp, 2},
1293 Counter{cSubReqToE2, 1},
1294 Counter{cSubRespFromE2, 1},
1295 Counter{cSubRespToXapp, 2},
1296 Counter{cMergedSubscriptions, 1},
1297 Counter{cUnmergedSubscriptions, 1},
1298 Counter{cSubDelReqFromXapp, 2},
1299 Counter{cSubDelReqToE2, 1},
1300 Counter{cSubDelRespFromE2, 1},
1301 Counter{cSubDelRespToXapp, 2},
1305 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1307 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1308 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1309 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1310 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1313 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1315 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1316 //crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1317 //e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1318 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1320 resp, _ := xapp.Subscription.QuerySubscriptions()
1321 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1322 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1323 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
1326 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1327 //e2termConn1.RecvSubsDelReq(t)
1328 //e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1329 xappConn1.RecvSubsDelResp(t, deltrans1)
1330 //Wait that subs is cleaned
1331 //mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1334 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1335 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1336 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1337 xappConn2.RecvSubsDelResp(t, deltrans2)
1338 //Wait that subs is cleaned
1339 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1341 xappConn1.TestMsgChanEmpty(t)
1342 xappConn2.TestMsgChanEmpty(t)
1343 e2termConn1.TestMsgChanEmpty(t)
1344 mainCtrl.wait_registry_empty(t, 10)
1346 mainCtrl.VerifyCounterValues(t)
1349 //-----------------------------------------------------------------------------
1350 // TestSubReqAndSubDelOkSameActionParallel
1353 // +-------+ +-------+ +---------+ +---------+
1354 // | xapp2 | | xapp1 | | submgr | | e2term |
1355 // +-------+ +-------+ +---------+ +---------+
1360 // | |------------->| |
1363 // | | |------------->|
1365 // |--------------------------->| |
1367 // | | |<-------------|
1369 // | |<-------------| |
1372 // |<---------------------------| |
1374 // | | SubDelReq 1 | |
1375 // | |------------->| |
1377 // | | SubDelResp 1 | |
1378 // | |<-------------| |
1380 // | SubDelReq 2 | |
1381 // |--------------------------->| |
1383 // | | | SubDelReq 2 |
1384 // | | |------------->|
1386 // | | | SubDelReq 2 |
1387 // | | |------------->|
1389 // | SubDelResp 2 | |
1390 // |<---------------------------| |
1392 //-----------------------------------------------------------------------------
1393 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1394 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1397 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1399 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1400 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1403 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1405 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1408 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1409 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1412 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1415 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1416 xappConn1.RecvSubsDelResp(t, deltrans1)
1419 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1420 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1421 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1422 xappConn2.RecvSubsDelResp(t, deltrans2)
1424 //Wait that subs is cleaned
1425 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1427 xappConn1.TestMsgChanEmpty(t)
1428 xappConn2.TestMsgChanEmpty(t)
1429 e2termConn1.TestMsgChanEmpty(t)
1430 mainCtrl.wait_registry_empty(t, 10)
1433 //-----------------------------------------------------------------------------
1434 // TestSubReqAndSubDelNokSameActionParallel
1437 // +-------+ +-------+ +---------+ +---------+
1438 // | xapp2 | | xapp1 | | submgr | | e2term |
1439 // +-------+ +-------+ +---------+ +---------+
1444 // | |------------->| |
1447 // | | |------------->|
1449 // |--------------------------->| |
1451 // | | |<-------------|
1453 // | | | SubDelReq |
1454 // | | |------------->|
1455 // | | | SubDelResp |
1456 // | | |<-------------|
1459 // | |<-------------| |
1462 // |<---------------------------| |
1464 //-----------------------------------------------------------------------------
1465 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1466 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1469 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1471 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1473 // E2t: Receive SubsReq (first)
1474 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1477 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1479 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1480 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1481 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1483 // E2t: send SubsFail (first)
1484 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1485 fparams1.Set(crereq1)
1486 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1488 // E2t: internal delete
1489 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1490 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1493 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1495 xappConn2.RecvSubsFail(t, cretrans2)
1497 //Wait that subs is cleaned
1498 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1500 xappConn1.TestMsgChanEmpty(t)
1501 xappConn2.TestMsgChanEmpty(t)
1502 e2termConn1.TestMsgChanEmpty(t)
1503 mainCtrl.wait_registry_empty(t, 10)
1506 //-----------------------------------------------------------------------------
1507 // TestSubReqAndSubDelNoAnswerSameActionParallel
1510 // +-------+ +-------+ +---------+ +---------+
1511 // | xapp2 | | xapp1 | | submgr | | e2term |
1512 // +-------+ +-------+ +---------+ +---------+
1517 // | |------------->| |
1520 // | | |------------->|
1522 // |--------------------------->| |
1525 // | | |------------->|
1528 // | | | SubDelReq |
1529 // | | |------------->|
1531 // | | | SubDelResp |
1532 // | | |<-------------|
1534 //-----------------------------------------------------------------------------
1535 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1536 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1539 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1541 xappConn1.SendSubsReq(t, rparams1, nil)
1543 crereq1, _ := e2termConn1.RecvSubsReq(t)
1546 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1548 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1549 xappConn2.SendSubsReq(t, rparams2, nil)
1550 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1552 //Req1 (retransmitted)
1553 e2termConn1.RecvSubsReq(t)
1555 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1556 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1558 //Wait that subs is cleaned
1559 mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10)
1561 xappConn1.TestMsgChanEmpty(t)
1562 xappConn2.TestMsgChanEmpty(t)
1563 e2termConn1.TestMsgChanEmpty(t)
1564 mainCtrl.wait_registry_empty(t, 15)
1567 //----------------------------- Policy cases ---------------------------------
1568 //-----------------------------------------------------------------------------
1569 // TestSubReqPolicyAndSubDelOk
1572 // +-------+ +---------+ +---------+
1573 // | xapp | | submgr | | e2term |
1574 // +-------+ +---------+ +---------+
1577 // |------------->| |
1580 // | |------------->|
1583 // | |<-------------|
1586 // |<-------------| |
1590 // |------------->| |
1593 // | |------------->|
1596 // | |<-------------|
1599 // |<-------------| |
1601 //-----------------------------------------------------------------------------
1602 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
1603 CaseBegin("TestSubReqAndSubDelOk")
1605 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1607 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1608 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1610 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1611 e2termConn1.SendSubsResp(t, crereq, cremsg)
1612 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1613 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1614 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1616 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1617 xappConn1.RecvSubsDelResp(t, deltrans)
1619 //Wait that subs is cleaned
1620 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1622 xappConn1.TestMsgChanEmpty(t)
1623 xappConn2.TestMsgChanEmpty(t)
1624 e2termConn1.TestMsgChanEmpty(t)
1625 mainCtrl.wait_registry_empty(t, 10)
1628 //-----------------------------------------------------------------------------
1629 // TestSubReqPolicyChangeAndSubDelOk
1632 // +-------+ +---------+ +---------+
1633 // | xapp | | submgr | | e2term |
1634 // +-------+ +---------+ +---------+
1637 // |------------->| |
1640 // | |------------->|
1643 // | |<-------------|
1646 // |<-------------| |
1649 // |------------->| |
1652 // | |------------->|
1655 // | |<-------------|
1658 // |<-------------| |
1661 // |------------->| |
1664 // | |------------->|
1667 // | |<-------------|
1670 // |<-------------| |
1672 //-----------------------------------------------------------------------------
1674 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
1675 CaseBegin("TestSubReqAndSubDelOk")
1677 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1679 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1680 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1682 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1683 e2termConn1.SendSubsResp(t, crereq, cremsg)
1684 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1687 rparams1.Req.RequestId.InstanceId = e2SubsId
1688 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
1689 xappConn1.SendSubsReq(t, rparams1, cretrans)
1691 crereq, cremsg = e2termConn1.RecvSubsReq(t)
1692 e2termConn1.SendSubsResp(t, crereq, cremsg)
1693 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1694 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1695 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1697 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1698 xappConn1.RecvSubsDelResp(t, deltrans)
1700 //Wait that subs is cleaned
1701 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1703 xappConn1.TestMsgChanEmpty(t)
1704 xappConn2.TestMsgChanEmpty(t)
1705 e2termConn1.TestMsgChanEmpty(t)
1706 mainCtrl.wait_registry_empty(t, 10)
1709 //-----------------------------------------------------------------------------
1710 // TestSubReqAndSubDelOkTwoE2termParallel
1713 // +-------+ +---------+ +---------+ +---------+
1714 // | xapp | | submgr | | e2term1 | | e2term2 |
1715 // +-------+ +---------+ +---------+ +---------+
1720 // |------------->| | |
1723 // | |------------->| |
1726 // |------------->| | |
1729 // | |---------------------------->|
1732 // | |<-------------| |
1734 // |<-------------| | |
1736 // | |<----------------------------|
1738 // |<-------------| | |
1740 // | [SUBS 1 DELETE] | |
1742 // | [SUBS 2 DELETE] | |
1745 //-----------------------------------------------------------------------------
1746 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
1747 CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
1750 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1751 xappConn1.SendSubsReq(t, nil, cretrans1)
1752 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1754 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
1755 xappConn1.SendSubsReq(t, nil, cretrans2)
1756 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
1759 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1760 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1763 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
1764 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1767 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1768 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1769 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1770 xappConn1.RecvSubsDelResp(t, deltrans1)
1771 //Wait that subs is cleaned
1772 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1775 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
1776 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
1777 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
1778 xappConn1.RecvSubsDelResp(t, deltrans2)
1779 //Wait that subs is cleaned
1780 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1782 xappConn1.TestMsgChanEmpty(t)
1783 xappConn2.TestMsgChanEmpty(t)
1784 e2termConn1.TestMsgChanEmpty(t)
1785 e2termConn2.TestMsgChanEmpty(t)
1786 mainCtrl.wait_registry_empty(t, 10)
1789 //-----------------------------------------------------------------------------
1790 // TestSubReqInsertAndSubDelOk
1793 // +-------+ +---------+ +---------+
1794 // | xapp | | submgr | | e2term |
1795 // +-------+ +---------+ +---------+
1798 // |------------->| |
1801 // | |------------->|
1804 // | |<-------------|
1807 // |<-------------| |
1811 // |------------->| |
1814 // | |------------->|
1817 // | |<-------------|
1820 // |<-------------| |
1822 //-----------------------------------------------------------------------------
1823 func TestSubReqInsertAndSubDelOk(t *testing.T) {
1824 CaseBegin("TestInsertSubReqAndSubDelOk")
1826 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1828 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeInsert
1829 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1831 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1832 e2termConn1.SendSubsResp(t, crereq, cremsg)
1833 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1834 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1835 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1837 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1838 xappConn1.RecvSubsDelResp(t, deltrans)
1840 //Wait that subs is cleaned
1841 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1843 xappConn1.TestMsgChanEmpty(t)
1844 xappConn2.TestMsgChanEmpty(t)
1845 e2termConn1.TestMsgChanEmpty(t)
1846 mainCtrl.wait_registry_empty(t, 10)
1849 //-----------------------------------------------------------------------------
1850 // TestSubReqRetransmissionWithSameSubIdDiffXid
1852 // This case simulates case where xApp restarts and starts sending same
1853 // subscription requests which have already subscribed successfully
1856 // +-------+ +---------+ +---------+
1857 // | xapp | | submgr | | e2term |
1858 // +-------+ +---------+ +---------+
1861 // |------------->| |
1864 // | |------------->|
1867 // | |<-------------|
1870 // |<-------------| |
1872 // | xApp restart | |
1875 // | (retrans with same xApp generated subid but diff xid)
1876 // |------------->| |
1879 // |<-------------| |
1881 // | [SUBS DELETE] |
1884 //-----------------------------------------------------------------------------
1885 func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) {
1886 CaseBegin("TestSubReqRetransmissionWithSameSubIdDiffXid")
1889 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1890 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1891 e2termConn1.SendSubsResp(t, crereq, cremsg)
1892 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1894 // xApp restart here
1895 // --> artificial delay
1896 <-time.After(1 * time.Second)
1899 cretrans = xappConn1.SendSubsReq(t, nil, nil) //Retransmitted SubReq
1900 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1903 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1904 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1905 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1906 xappConn1.RecvSubsDelResp(t, deltrans)
1908 //Wait that subs is cleaned
1909 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1911 xappConn1.TestMsgChanEmpty(t)
1912 xappConn2.TestMsgChanEmpty(t)
1913 e2termConn1.TestMsgChanEmpty(t)
1914 mainCtrl.wait_registry_empty(t, 10)
1917 //-----------------------------------------------------------------------------
1918 // TestSubReqNokAndSubDelOkWithRestartInMiddle
1921 // +-------+ +---------+ +---------+
1922 // | xapp | | submgr | | e2term |
1923 // +-------+ +---------+ +---------+
1926 // |------------->| |
1929 // | |------------->|
1934 // | Submgr restart |
1938 // | |------------->|
1941 // | |<-------------|
1944 //-----------------------------------------------------------------------------
1946 func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
1947 CaseBegin("TestSubReqNokAndSubDelOkWithRestartInMiddle")
1949 // Remove possible existing subscrition
1950 mainCtrl.removeExistingSubscriptions(t)
1952 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
1953 xappConn1.SendSubsReq(t, nil, nil)
1954 e2termConn1.RecvSubsReq(t)
1955 mainCtrl.SetResetTestFlag(t, false)
1957 resp, _ := xapp.Subscription.QuerySubscriptions()
1958 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1959 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
1960 e2SubsId := uint32(resp[0].SubscriptionID)
1961 t.Logf("e2SubsId = %v", e2SubsId)
1963 mainCtrl.SimulateRestart(t)
1964 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
1966 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1967 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1969 // Wait that subs is cleaned
1970 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1972 xappConn1.TestMsgChanEmpty(t)
1973 xappConn2.TestMsgChanEmpty(t)
1974 e2termConn1.TestMsgChanEmpty(t)
1975 mainCtrl.wait_registry_empty(t, 10)
1978 //-----------------------------------------------------------------------------
1979 // TestSubReqAndSubDelOkWithRestartInMiddle
1982 // +-------+ +---------+ +---------+
1983 // | xapp | | submgr | | e2term |
1984 // +-------+ +---------+ +---------+
1987 // |------------->| |
1990 // | |------------->|
1993 // | |<-------------|
1996 // |<-------------| |
1999 // | Submgr restart |
2002 // |------------->| |
2005 // | |------------->|
2008 // | |<-------------|
2011 // |<-------------| |
2013 //-----------------------------------------------------------------------------
2015 func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
2016 CaseBegin("TestSubReqAndSubDelOkWithRestartInMiddle")
2018 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2019 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2020 e2termConn1.SendSubsResp(t, crereq, cremsg)
2021 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2023 // Check subscription
2024 resp, _ := xapp.Subscription.QuerySubscriptions()
2025 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2026 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2027 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2029 mainCtrl.SimulateRestart(t)
2030 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2032 // Check that subscription is restored correctly after restart
2033 resp, _ = xapp.Subscription.QuerySubscriptions()
2034 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2035 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2036 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2038 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2039 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2040 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2041 xappConn1.RecvSubsDelResp(t, deltrans)
2043 //Wait that subs is cleaned
2044 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2046 xappConn1.TestMsgChanEmpty(t)
2047 xappConn2.TestMsgChanEmpty(t)
2048 e2termConn1.TestMsgChanEmpty(t)
2049 mainCtrl.wait_registry_empty(t, 10)
2052 //-----------------------------------------------------------------------------
2053 // TestSubReqAndSubDelOkSameActionWithRestartsInMiddle
2056 // +-------+ +-------+ +---------+ +---------+
2057 // | xapp2 | | xapp1 | | submgr | | e2term |
2058 // +-------+ +-------+ +---------+ +---------+
2063 // | |------------->| |
2066 // | | |------------->|
2068 // | | |<-------------|
2070 // | |<-------------| |
2073 // | submgr restart |
2078 // |--------------------------->| |
2081 // |<---------------------------| |
2083 // | | SubDelReq 1 | |
2084 // | |------------->| |
2086 // | | SubDelResp 1 | |
2087 // | |<-------------| |
2091 // | submgr restart |
2094 // | SubDelReq 2 | |
2095 // |--------------------------->| |
2097 // | | | SubDelReq 2 |
2098 // | | |------------->|
2100 // | | | SubDelReq 2 |
2101 // | | |------------->|
2103 // | SubDelResp 2 | |
2104 // |<---------------------------| |
2106 //-----------------------------------------------------------------------------
2108 func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
2109 CaseBegin("TestSubReqAndSubDelOkSameActionWithRestartsInMiddle")
2112 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2114 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2115 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2116 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2117 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2120 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2122 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2123 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
2125 // Check subscription
2126 resp, _ := xapp.Subscription.QuerySubscriptions() ////////////////////////////////
2127 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2128 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2129 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2131 mainCtrl.SimulateRestart(t)
2132 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2134 // Check that subscription is restored correctly after restart
2135 resp, _ = xapp.Subscription.QuerySubscriptions()
2136 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2137 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2138 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2141 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2142 xapp.Logger.Debug("xappConn1.RecvSubsDelResp")
2143 xappConn1.RecvSubsDelResp(t, deltrans1)
2144 xapp.Logger.Debug("xappConn1.RecvSubsDelResp received")
2146 mainCtrl.SimulateRestart(t)
2147 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2150 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
2151 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2153 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2154 xappConn2.RecvSubsDelResp(t, deltrans2)
2156 //Wait that subs is cleaned
2157 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2159 xappConn1.TestMsgChanEmpty(t)
2160 xappConn2.TestMsgChanEmpty(t)
2161 e2termConn1.TestMsgChanEmpty(t)
2162 mainCtrl.wait_registry_empty(t, 10)
2165 //*****************************************************************************
2166 // REST interface test cases
2167 //*****************************************************************************
2169 //-----------------------------------------------------------------------------
2170 // Test debug GET and POST requests
2173 // +-------+ +---------+
2174 // | user | | submgr |
2175 // +-------+ +---------+
2182 func TestGetSubscriptions(t *testing.T) {
2184 mainCtrl.sendGetRequest(t, "localhost:8088", "/ric/v1/subscriptions")
2187 func TestGetSymptomData(t *testing.T) {
2189 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/symptomdata")
2192 func TestPostdeleteSubId(t *testing.T) {
2194 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/deletesubid=1")
2197 func TestPostEmptyDb(t *testing.T) {
2199 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/emptydb")
2202 //-----------------------------------------------------------------------------
2203 // TestRESTSubReqAndRouteNok
2206 // +-------+ +---------+ +---------+
2207 // | xapp | | submgr | | rtmgr |
2208 // +-------+ +---------+ +---------+
2211 // |---------------->| |
2213 // | RESTSubResp | |
2214 // |<----------------| |
2215 // | | RouteCreate |
2216 // | |------------->|
2218 // | | RouteCreate |
2220 // | |(Bad request) |
2221 // | |<-------------|
2223 // |<----------------| |
2225 // | [SUBS INT DELETE] |
2227 // | RESTSubDelReq | |
2228 // |---------------->| |
2229 // | RESTSubDelResp | |
2230 // |<----------------| |
2232 //-----------------------------------------------------------------------------
2233 func TestRESTSubReqAndRouteNok(t *testing.T) {
2234 CaseBegin("TestRESTSubReqAndRouteNok")
2236 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2237 Counter{cSubReqFromXapp, 1},
2238 Counter{cRouteCreateFail, 1},
2239 Counter{cSubRespToXapp, 1},
2240 Counter{cSubDelReqFromXapp, 1},
2241 Counter{cSubDelRespToXapp, 1},
2244 const subReqCount int = 1
2245 const parameterSet = 1
2246 const actionDefinitionPresent bool = true
2247 const actionParamCount int = 1
2248 // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
2249 waiter := rtmgrHttp.AllocNextSleep(50, false)
2250 newSubsId := mainCtrl.get_registry_next_subid(t)
2253 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2254 restSubId := xappConn1.SendRESTSubsReq(t, params)
2255 xappConn1.ExpectRESTNotification(t, restSubId)
2256 waiter.WaitResult(t)
2258 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2259 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
2262 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2264 // Wait that subs is cleaned
2265 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2266 waitSubsCleanup(t, e2SubsId, 10)
2267 mainCtrl.VerifyCounterValues(t)
2270 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
2271 CaseBegin("TestSubReqAndRouteUpdateNok")
2273 //Init counter check
2274 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2275 Counter{cSubReqFromXapp, 2},
2276 Counter{cSubReqToE2, 1},
2277 Counter{cSubRespFromE2, 1},
2278 Counter{cSubRespToXapp, 2},
2279 Counter{cRouteCreateUpdateFail, 1},
2280 Counter{cSubDelReqFromXapp, 1},
2281 Counter{cSubDelReqToE2, 1},
2282 Counter{cSubDelRespFromE2, 1},
2283 Counter{cSubDelRespToXapp, 1},
2286 var params *teststube2ap.RESTSubsReqParams = nil
2289 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2291 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2293 // xapp2 ROUTE creation shall fail with 400 from rtmgr -> submgr
2294 waiter := rtmgrHttp.AllocNextEvent(false)
2295 newSubsId := mainCtrl.get_registry_next_subid(t)
2296 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2297 params.SetMeid("RAN_NAME_1")
2298 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2299 xapp.Logger.Info("Send REST subscriber request for second subscriber : %v", restSubId2)
2300 xappConn2.ExpectRESTNotification(t, restSubId2)
2301 waiter.WaitResult(t)
2302 // e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) - TOD: missing delete
2303 xappConn2.WaitRESTNotification(t, restSubId2)
2305 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2307 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2309 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2310 //Wait that subs is cleaned
2311 waitSubsCleanup(t, e2SubsId, 10)
2313 mainCtrl.VerifyCounterValues(t)
2316 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
2317 CaseBegin("TestRESTSubDelReqAndRouteDeleteNok")
2319 // Init counter check
2320 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2321 Counter{cSubReqFromXapp, 1},
2322 Counter{cSubReqToE2, 1},
2323 Counter{cSubRespFromE2, 1},
2324 Counter{cSubRespToXapp, 1},
2325 Counter{cSubDelReqFromXapp, 1},
2326 Counter{cRouteDeleteFail, 1},
2327 Counter{cSubDelReqToE2, 1},
2328 Counter{cSubDelRespFromE2, 1},
2329 Counter{cSubDelRespToXapp, 1},
2332 var params *teststube2ap.RESTSubsReqParams = nil
2335 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2337 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2339 waiter := rtmgrHttp.AllocNextEvent(false)
2340 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2341 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2342 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2343 waiter.WaitResult(t)
2345 waitSubsCleanup(t, e2SubsId, 10)
2347 mainCtrl.VerifyCounterValues(t)
2350 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
2351 CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok")
2353 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2354 Counter{cSubReqFromXapp, 2},
2355 Counter{cSubReqToE2, 1},
2356 Counter{cSubRespFromE2, 1},
2357 Counter{cSubRespToXapp, 2},
2358 Counter{cSubDelReqFromXapp, 2},
2359 Counter{cRouteDeleteUpdateFail, 1},
2360 Counter{cSubDelReqToE2, 1},
2361 Counter{cSubDelRespFromE2, 1},
2362 Counter{cSubDelRespToXapp, 2},
2365 var params *teststube2ap.RESTSubsReqParams = nil
2368 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2370 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2371 restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1")
2373 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
2375 //Del1, this shall fail on rtmgr side
2376 waiter := rtmgrHttp.AllocNextEvent(false)
2377 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2378 waiter.WaitResult(t)
2380 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"})
2383 deleteXapp2Subscription(t, &restSubId2)
2385 waitSubsCleanup(t, e2SubsId2, 10)
2387 mainCtrl.VerifyCounterValues(t)
2390 //-----------------------------------------------------------------------------
2391 // TestRESTSubReqRetransmission
2394 // +-------+ +---------+ +---------+
2395 // | xapp | | submgr | | e2term |
2396 // +-------+ +---------+ +---------+
2398 // | RESTSubReq1 | |
2399 // |---------------->| |
2401 // | RESTSubResp | |
2402 // |<----------------| |
2404 // | |------------->|
2406 // | RESTSubReq2 | |
2408 // |---------------->| |
2411 // | |------------->|
2412 // | RESTSubResp2 | |
2413 // |<----------------| |
2415 // | |<-------------|
2417 // |<----------------| |
2419 // | |<-------------|
2421 // |<----------------| |
2423 // | [SUBS DELETE] |
2426 //-----------------------------------------------------------------------------
2428 func TestRESTSubReqRetransmission(t *testing.T) {
2429 CaseBegin("TestRESTSubReqRetransmission")
2431 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2432 Counter{cSubReqFromXapp, 2},
2433 Counter{cSubReqToE2, 2},
2434 Counter{cSubRespFromE2, 2},
2435 Counter{cSubRespToXapp, 2},
2436 Counter{cSubDelReqFromXapp, 2},
2437 Counter{cSubDelReqToE2, 2},
2438 Counter{cSubDelRespFromE2, 2},
2439 Counter{cSubDelRespToXapp, 2},
2441 // Retry/duplicate will get the same way as the first request. Submgr cannot detect duplicate RESTRequests
2442 // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
2443 // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
2446 const subReqCount int = 1
2447 const parameterSet = 1
2448 const actionDefinitionPresent bool = true
2449 const actionParamCount int = 1
2451 // In order to force both XAPP's to create their own subscriptions, force rtmgr to block a while so that 2nd create
2452 // gets into execution before the rtmgrg responds for the first one.
2453 waiter := rtmgrHttp.AllocNextSleep(10, true)
2454 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2455 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
2456 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2458 waiter.WaitResult(t)
2460 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
2462 // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
2463 // the order is not significant he6re.
2464 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2465 e2termConn1.SendSubsResp(t, crereq, cremsg)
2466 crereq, cremsg = e2termConn1.RecvSubsReq(t)
2467 e2termConn1.SendSubsResp(t, crereq, cremsg)
2469 e2SubsIdA := <-xappConn1.ListedRESTNotifications
2470 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
2471 e2SubsIdB := <-xappConn1.ListedRESTNotifications
2472 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
2475 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
2476 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2477 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2480 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
2481 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2482 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2484 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
2486 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
2488 mainCtrl.VerifyCounterValues(t)
2491 func TestRESTSubDelReqRetransmission(t *testing.T) {
2492 CaseBegin("TestRESTSubDelReqRetransmission")
2494 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2495 Counter{cSubReqFromXapp, 1},
2496 Counter{cSubReqToE2, 1},
2497 Counter{cSubRespFromE2, 1},
2498 Counter{cSubRespToXapp, 1},
2499 Counter{cSubDelReqFromXapp, 2},
2500 Counter{cSubDelReqToE2, 1},
2501 Counter{cSubDelRespFromE2, 1},
2502 Counter{cSubDelRespToXapp, 1},
2505 var params *teststube2ap.RESTSubsReqParams = nil
2508 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2510 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2513 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2514 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2516 seqBef := mainCtrl.get_msgcounter(t)
2517 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2518 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
2520 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2522 waitSubsCleanup(t, e2SubsId, 10)
2524 mainCtrl.VerifyCounterValues(t)
2527 //-----------------------------------------------------------------------------
2528 // TestRESTSubReqDelReq
2531 // +-------+ +---------+ +---------+
2532 // | xapp | | submgr | | e2term |
2533 // +-------+ +---------+ +---------+
2536 // |---------------->| |
2538 // | RESTSubResp | |
2539 // |<----------------| |
2541 // | |------------->|
2542 // | RESTSubDelReq | |
2543 // |---------------->| |
2544 // | RESTSubDelResp | |
2546 // |<----------------| |
2548 // | |<-------------|
2550 // |<----------------| |
2552 // | [SUBS DELETE] |
2555 //-----------------------------------------------------------------------------
2556 func TestRESTSubReqDelReq(t *testing.T) {
2557 CaseBegin("TestRESTSubReqDelReq")
2559 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2560 Counter{cSubReqFromXapp, 1},
2561 Counter{cSubReqToE2, 1},
2562 Counter{cSubRespFromE2, 1},
2563 Counter{cSubRespToXapp, 1},
2564 Counter{cSubDelReqFromXapp, 2},
2565 Counter{cSubDelReqToE2, 1},
2566 Counter{cSubDelRespFromE2, 1},
2567 Counter{cSubDelRespToXapp, 1},
2570 const subReqCount int = 1
2571 const parameterSet = 1
2572 const actionDefinitionPresent bool = true
2573 const actionParamCount int = 1
2576 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2577 restSubId := xappConn1.SendRESTSubsReq(t, params)
2579 // Del. This will fail as processing of the subscription
2580 // is still ongoing in submgr. Deletion is not allowed before
2581 // subscription creation has been completed.
2582 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2583 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2584 xappConn1.ExpectRESTNotification(t, restSubId)
2585 e2termConn1.SendSubsResp(t, crereq, cremsg)
2586 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2589 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2591 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2592 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2594 // Wait that subs is cleaned
2595 waitSubsCleanup(t, e2SubsId, 10)
2596 mainCtrl.VerifyCounterValues(t)
2600 func TestRESTSubDelReqCollision(t *testing.T) {
2601 CaseBegin("TestRESTSubDelReqCollision - not relevant for REST API")
2604 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
2605 CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel")
2607 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2608 Counter{cSubReqFromXapp, 2},
2609 Counter{cSubReqToE2, 2},
2610 Counter{cSubRespFromE2, 2},
2611 Counter{cSubRespToXapp, 2},
2612 Counter{cSubDelReqFromXapp, 2},
2613 Counter{cSubDelReqToE2, 2},
2614 Counter{cSubDelRespFromE2, 2},
2615 Counter{cSubDelRespToXapp, 2},
2619 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2620 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
2621 xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
2624 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2625 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2626 xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
2628 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2629 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
2631 //XappConn1 receives both of the responses
2632 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
2635 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2637 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
2639 e2SubsIdA := <-xappConn1.ListedRESTNotifications
2640 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
2641 e2SubsIdB := <-xappConn1.ListedRESTNotifications
2642 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
2645 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
2647 deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
2649 //Wait that subs is cleaned
2650 mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
2651 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
2653 mainCtrl.VerifyCounterValues(t)
2657 func TestRESTSameSubsDiffRan(t *testing.T) {
2658 CaseBegin("TestRESTSameSubsDiffRan")
2660 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2661 Counter{cSubReqFromXapp, 2},
2662 Counter{cSubReqToE2, 2},
2663 Counter{cSubRespFromE2, 2},
2664 Counter{cSubRespToXapp, 2},
2665 Counter{cSubDelReqFromXapp, 2},
2666 Counter{cSubDelReqToE2, 2},
2667 Counter{cSubDelRespFromE2, 2},
2668 Counter{cSubDelRespToXapp, 2},
2671 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2672 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
2673 xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
2675 params = xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2676 params.SetMeid("RAN_NAME_2")
2677 restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
2678 xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
2681 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
2683 deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
2685 //Wait that subs is cleaned
2686 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
2687 waitSubsCleanup(t, e2SubsId2, 10)
2689 mainCtrl.VerifyCounterValues(t)
2693 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
2694 CaseBegin("TestRESTSubReqRetryInSubmgr start")
2696 // Init counter check
2697 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2698 Counter{cSubReqFromXapp, 1},
2699 Counter{cSubReqToE2, 1},
2700 Counter{cSubReReqToE2, 1},
2701 Counter{cSubRespFromE2, 1},
2702 Counter{cSubRespToXapp, 1},
2703 Counter{cSubDelReqFromXapp, 1},
2704 Counter{cSubDelReqToE2, 1},
2705 Counter{cSubDelRespFromE2, 1},
2706 Counter{cSubDelRespToXapp, 1},
2709 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2710 restSubId := xappConn1.SendRESTSubsReq(t, params)
2712 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
2714 // Catch the first message and ignore it
2715 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2716 xapp.Logger.Info("Ignore REST subscriber request for subscriber : %v", restSubId)
2718 // The second request is being handled normally
2719 crereq, cremsg = e2termConn1.RecvSubsReq(t)
2720 xappConn1.ExpectRESTNotification(t, restSubId)
2721 e2termConn1.SendSubsResp(t, crereq, cremsg)
2722 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2724 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2726 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2728 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2729 //Wait that subs is cleaned
2730 waitSubsCleanup(t, e2SubsId, 10)
2732 mainCtrl.VerifyCounterValues(t)
2736 //-----------------------------------------------------------------------------
2737 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
2740 // +-------+ +---------+ +---------+
2741 // | xapp | | submgr | | e2term |
2742 // +-------+ +---------+ +---------+
2745 // |---------------->| |
2747 // | RESTSubResp | |
2748 // |<----------------| |
2750 // | |------------->|
2754 // | |------------->|
2757 // | |------------->|
2761 // | |------------->|
2765 // | |<-------------|
2768 // |<----------------| |
2770 // | [SUBS DELETE] |
2773 //-----------------------------------------------------------------------------
2774 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
2775 CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
2777 // Init counter check
2778 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2779 Counter{cSubReqFromXapp, 1},
2780 Counter{cSubReqToE2, 1},
2781 Counter{cSubReReqToE2, 1},
2782 Counter{cSubReqTimerExpiry, 2},
2783 Counter{cSubDelReqToE2, 1},
2784 Counter{cSubDelRespFromE2, 1},
2787 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2788 restSubId := xappConn1.SendRESTSubsReq(t, params)
2789 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
2791 e2termConn1.RecvSubsReq(t)
2792 xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
2794 e2termConn1.RecvSubsReq(t)
2795 xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
2797 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2798 xappConn1.ExpectRESTNotification(t, restSubId)
2799 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2800 // e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) - TODO: Should we delete this?
2801 xappConn1.WaitRESTNotification(t, restSubId)
2803 // Wait that subs is cleaned
2804 waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
2806 mainCtrl.VerifyCounterValues(t)
2809 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
2810 CaseBegin("TestREST2eTermNotRespondingToSubReq start")
2812 // Init counter check
2813 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2814 Counter{cSubReqFromXapp, 1},
2815 Counter{cSubReqToE2, 1},
2816 Counter{cSubReReqToE2, 1},
2817 Counter{cSubReqTimerExpiry, 2},
2818 Counter{cSubDelReqToE2, 1},
2819 Counter{cSubDelReqTimerExpiry, 2},
2822 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2823 restSubId := xappConn1.SendRESTSubsReq(t, params)
2824 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
2826 e2termConn1.RecvSubsReq(t)
2827 xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
2829 e2termConn1.RecvSubsReq(t)
2830 xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
2832 e2termConn1.RecvSubsDelReq(t)
2833 xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
2835 xappConn1.ExpectRESTNotification(t, restSubId)
2836 e2termConn1.RecvSubsDelReq(t)
2837 xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
2839 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2841 waitSubsCleanup(t, e2SubsId, 10)
2843 mainCtrl.VerifyCounterValues(t)
2847 //-----------------------------------------------------------------------------
2848 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
2851 // +-------+ +---------+ +---------+
2852 // | xapp | | submgr | | e2term |
2853 // +-------+ +---------+ +---------+
2856 // |---------------->| |
2858 // | RESTSubResp | |
2859 // |<----------------| |
2861 // | |------------->|
2865 // | |------------->|
2868 // | |------------->|
2872 // | |------------->|
2876 // | |<-------------|
2879 // |<----------------| |
2881 // | [SUBS DELETE] |
2884 //-----------------------------------------------------------------------------
2885 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
2886 CaseBegin("TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr start")
2888 // Init counter check
2889 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2890 Counter{cSubReqFromXapp, 1},
2891 Counter{cSubReqToE2, 1},
2892 Counter{cSubReReqToE2, 1},
2893 Counter{cSubReqTimerExpiry, 2},
2894 Counter{cSubDelReqToE2, 1},
2895 Counter{cSubDelReReqToE2, 1},
2896 Counter{cSubDelReqTimerExpiry, 2},
2899 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2900 restSubId := xappConn1.SendRESTSubsReq(t, params)
2901 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
2903 e2termConn1.RecvSubsReq(t)
2904 xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
2906 e2termConn1.RecvSubsReq(t)
2907 xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
2909 e2termConn1.RecvSubsDelReq(t)
2910 xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
2912 xappConn1.ExpectRESTNotification(t, restSubId)
2913 e2termConn1.RecvSubsDelReq(t)
2914 xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
2916 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2918 waitSubsCleanup(t, e2SubsId, 10)
2920 mainCtrl.VerifyCounterValues(t)
2923 //-----------------------------------------------------------------------------
2924 // TestRESTSubReqSubFailRespInSubmgr
2927 // +-------+ +---------+ +---------+
2928 // | xapp | | submgr | | e2term |
2929 // +-------+ +---------+ +---------+
2932 // |---------------->| |
2934 // | RESTSubResp | |
2935 // |<----------------| |
2937 // | |------------->|
2940 // | |<-------------|
2943 // | |------------->|
2946 // | |<-------------|
2950 // |<----------------| |
2952 // | [SUBS DELETE] |
2955 //-----------------------------------------------------------------------------
2956 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
2957 CaseBegin("TestRESTSubReqSubFailRespInSubmgr")
2959 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2960 Counter{cSubReqFromXapp, 1},
2961 Counter{cSubReqToE2, 1},
2962 Counter{cSubFailFromE2, 1},
2963 Counter{cSubRespToXapp, 1},
2964 Counter{cSubDelReqFromXapp, 1},
2967 const subReqCount int = 1
2968 const parameterSet = 1
2969 const actionDefinitionPresent bool = true
2970 const actionParamCount int = 1
2972 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2973 restSubId := xappConn1.SendRESTSubsReq(t, params)
2975 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2976 fparams1 := &teststube2ap.E2StubSubsFailParams{}
2977 fparams1.Set(crereq1)
2978 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
2980 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2981 xappConn1.ExpectRESTNotification(t, restSubId)
2982 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2983 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2984 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
2986 // REST subscription sill there to be deleted
2987 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2989 // Wait that subs is cleaned
2990 waitSubsCleanup(t, e2SubsId, 10)
2992 mainCtrl.VerifyCounterValues(t)
2996 //-----------------------------------------------------------------------------
2997 // TestRESTSubDelReqRetryInSubmgr
3000 // +-------+ +---------+ +---------+
3001 // | xapp | | submgr | | e2term |
3002 // +-------+ +---------+ +---------+
3004 // | [SUBS CREATE] |
3007 // | RESTSubDelReq | |
3008 // |---------------->| |
3010 // | RESTSubDelResp | |
3011 // |<----------------| |
3013 // | |------------->|
3016 // | |------------->|
3019 // | |<-------------|
3022 //-----------------------------------------------------------------------------
3023 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
3024 CaseBegin("TestRESTSubDelReqRetryInSubmgr")
3026 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3027 Counter{cSubReqFromXapp, 1},
3028 Counter{cSubReqToE2, 1},
3029 Counter{cSubRespFromE2, 1},
3030 Counter{cSubRespToXapp, 1},
3031 Counter{cSubDelReqFromXapp, 1},
3032 Counter{cSubDelReqToE2, 1},
3033 Counter{cSubDelReReqToE2, 1},
3034 Counter{cSubDelRespFromE2, 1},
3035 Counter{cSubDelRespToXapp, 1},
3038 var params *teststube2ap.RESTSubsReqParams = nil
3039 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3042 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3044 // E2t: Receive 1st SubsDelReq
3045 e2termConn1.RecvSubsDelReq(t)
3047 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
3048 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3049 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3051 //Wait that subs is cleaned
3052 waitSubsCleanup(t, e2SubsId, 10)
3054 mainCtrl.VerifyCounterValues(t)
3057 //-----------------------------------------------------------------------------
3058 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
3061 // +-------+ +---------+ +---------+
3062 // | xapp | | submgr | | e2term |
3063 // +-------+ +---------+ +---------+
3065 // | [SUBS CREATE] |
3068 // | RESTSubDelReq | |
3069 // |---------------->| |
3071 // | RESTSubDelResp | |
3072 // |<----------------| |
3074 // | |------------->|
3077 // | |------------->|
3081 //-----------------------------------------------------------------------------
3082 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
3083 CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr")
3085 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3086 Counter{cSubReqFromXapp, 1},
3087 Counter{cSubReqToE2, 1},
3088 Counter{cSubRespFromE2, 1},
3089 Counter{cSubRespToXapp, 1},
3090 Counter{cSubDelReqFromXapp, 1},
3091 Counter{cSubDelReqToE2, 1},
3092 Counter{cSubDelReReqToE2, 1},
3093 Counter{cSubDelRespFromE2, 1},
3094 Counter{cSubDelRespToXapp, 1},
3098 var params *teststube2ap.RESTSubsReqParams = nil
3099 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3102 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3104 // E2t: Receive 1st SubsDelReq
3105 e2termConn1.RecvSubsDelReq(t)
3107 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
3108 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3109 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3111 //Wait that subs is cleaned
3112 waitSubsCleanup(t, e2SubsId, 10)
3114 mainCtrl.VerifyCounterValues(t)
3117 //-----------------------------------------------------------------------------
3118 // TestRESTSubDelReqSubDelFailRespInSubmgr
3121 // +-------+ +---------+ +---------+
3122 // | xapp | | submgr | | e2term |
3123 // +-------+ +---------+ +---------+
3125 // | [SUBS CREATE] |
3128 // | RESTSubDelReq | |
3129 // |---------------->| |
3131 // | RESTSubDelResp | |
3132 // |<----------------| |
3134 // | |------------->|
3137 // | |<-------------|
3140 //-----------------------------------------------------------------------------
3141 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
3142 CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr")
3144 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3145 Counter{cSubReqFromXapp, 1},
3146 Counter{cSubReqToE2, 1},
3147 Counter{cSubRespFromE2, 1},
3148 Counter{cSubRespToXapp, 1},
3149 Counter{cSubDelReqFromXapp, 1},
3150 Counter{cSubDelReqToE2, 1},
3151 Counter{cSubDelFailFromE2, 1},
3152 Counter{cSubDelRespToXapp, 1},
3156 var params *teststube2ap.RESTSubsReqParams = nil
3157 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3160 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3162 // E2t: Send receive SubsDelReq and send SubsDelFail
3163 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3164 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
3166 //Wait that subs is cleaned
3167 waitSubsCleanup(t, e2SubsId, 10)
3169 mainCtrl.VerifyCounterValues(t)
3172 //-----------------------------------------------------------------------------
3173 // TestRESTSubReqAndSubDelOkSameAction
3176 // +-------+ +-------+ +---------+ +---------+
3177 // | xapp2 | | xapp1 | | submgr | | e2term |
3178 // +-------+ +-------+ +---------+ +---------+
3180 // | | RESTSubReq1 | |
3181 // | |---------------->| |
3183 // | | RESTSubResp1 | |
3184 // | |<----------------| |
3187 // | | |------------->|
3189 // | | |<-------------|
3190 // | | RESTNotif1 | |
3191 // | |<----------------| |
3193 // | RESTSubReq2 | |
3194 // |------------------------------>| |
3196 // | RESTSubResp2 | |
3197 // |<------------------------------| |
3199 // | | RESTNotif2 | |
3200 // |<------------------------------| |
3202 // | | RESTSubDelReq1 | |
3203 // | |---------------->| |
3205 // | | RESTSubDelResp1 | |
3206 // | |<----------------| |
3208 // | RESTSubDelReq2 | |
3209 // |------------------------------>| |
3211 // | RESTSubDelResp2 | |
3212 // |<------------------------------| |
3214 // | | | SubDelReq2 |
3215 // | | |------------->|
3217 // | | | SubDelResp2 |
3218 // | | |<-------------|
3221 //-----------------------------------------------------------------------------
3222 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
3223 CaseBegin("TestRESTSubReqAndSubDelOkSameAction")
3225 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3226 Counter{cSubReqFromXapp, 2},
3227 Counter{cSubReqToE2, 1},
3228 Counter{cSubRespFromE2, 1},
3229 Counter{cSubRespToXapp, 2},
3230 Counter{cMergedSubscriptions, 1},
3231 Counter{cUnmergedSubscriptions, 1},
3232 Counter{cSubDelReqFromXapp, 2},
3233 Counter{cSubDelReqToE2, 1},
3234 Counter{cSubDelRespFromE2, 1},
3235 Counter{cSubDelRespToXapp, 2},
3239 var params *teststube2ap.RESTSubsReqParams = nil
3242 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3243 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
3246 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3247 params.SetMeid("RAN_NAME_1")
3249 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
3250 xappConn2.WaitRESTNotificationForAnySubscriptionId(t)
3251 waiter := rtmgrHttp.AllocNextSleep(10, true)
3252 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3253 waiter.WaitResult(t)
3254 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
3255 e2SubsId2 := <-xappConn2.RESTNotification
3256 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
3258 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
3261 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3264 deleteXapp2Subscription(t, &restSubId2)
3266 //Wait that subs is cleaned
3267 waitSubsCleanup(t, e2SubsId2, 10)
3269 mainCtrl.VerifyCounterValues(t)
3272 //-----------------------------------------------------------------------------
3273 // TestSubReqAndSubDelOkSameActionParallel
3276 // +-------+ +-------+ +---------+ +---------+
3277 // | xapp2 | | xapp1 | | submgr | | e2term |
3278 // +-------+ +-------+ +---------+ +---------+
3283 // | |------------->| |
3286 // | | |------------->|
3288 // |--------------------------->| |
3290 // | | |<-------------|
3292 // | |<-------------| |
3294 // | | |------------->|
3297 // | | |<-------------|
3299 // |<---------------------------| |
3301 // | | SubDelReq 1 | |
3302 // | |------------->| |
3304 // | | SubDelResp 1 | |
3305 // | |<-------------| |
3307 // | SubDelReq 2 | |
3308 // |--------------------------->| |
3310 // | | | SubDelReq 2 |
3311 // | | |------------->|
3313 // | | | SubDelReq 2 |
3314 // | | |------------->|
3316 // | SubDelResp 2 | |
3317 // |<---------------------------| |
3319 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
3320 CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel")
3322 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3323 Counter{cSubReqFromXapp, 2},
3324 Counter{cSubReqToE2, 2},
3325 Counter{cSubRespFromE2, 2},
3326 Counter{cSubRespToXapp, 2},
3327 Counter{cSubDelReqFromXapp, 2},
3328 Counter{cSubDelReqToE2, 2},
3329 Counter{cSubDelRespFromE2, 2},
3330 Counter{cSubDelRespToXapp, 2},
3333 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3334 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3335 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3337 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3338 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
3340 xappConn1.ExpectRESTNotification(t, restSubId1)
3341 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3342 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
3344 xappConn2.ExpectRESTNotification(t, restSubId2)
3345 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3346 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3347 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
3350 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3351 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3352 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3353 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3356 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
3357 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
3358 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
3360 waitSubsCleanup(t, e2SubsId2, 10)
3362 mainCtrl.VerifyCounterValues(t)
3365 //-----------------------------------------------------------------------------
3366 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
3369 // +-------+ +-------+ +---------+ +---------+
3370 // | xapp2 | | xapp1 | | submgr | | e2term |
3371 // +-------+ +-------+ +---------+ +---------+
3375 // | | RESTSubReq1 | |
3376 // | |---------------->| |
3378 // | | RESTSubResp1 | |
3379 // | |<----------------| |
3381 // | | |------------->|
3382 // | RESTSubReq2 | |
3383 // |------------------------------>| |
3385 // | RESTSubDelResp2 | |
3386 // |<------------------------------| |
3388 // | | |------------->|
3391 // | | | SubDelReq |
3392 // | | |------------->|
3394 // | | | SubDelResp |
3395 // | | |<-------------|
3396 // | | RESTNotif1 | |
3397 // | | unsuccess | |
3398 // | |<----------------| |
3400 // | | unsuccess | |
3401 // |<------------------------------| |
3403 // | | RESTSubDelReq1 | |
3404 // | |---------------->| |
3406 // | | RESTSubDelResp1 | |
3407 // | |<----------------| |
3409 // | RESTSubDelReq2 | |
3410 // |------------------------------>| |
3412 // | RESTSubDelResp2 | |
3413 // |<------------------------------| |
3415 //-----------------------------------------------------------------------------
3416 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
3417 CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
3419 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3420 Counter{cSubReqFromXapp, 2},
3421 Counter{cSubReqToE2, 1},
3422 Counter{cSubRespToXapp, 2},
3423 Counter{cSubDelReqFromXapp, 2},
3424 Counter{cSubDelReqToE2, 1},
3425 Counter{cSubDelRespFromE2, 1},
3426 Counter{cSubDelRespToXapp, 2},
3429 const subReqCount int = 1
3430 const parameterSet = 1
3431 const actionDefinitionPresent bool = true
3432 const actionParamCount int = 1
3435 params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3436 restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
3437 crereq1, _ := e2termConn1.RecvSubsReq(t)
3440 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
3441 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3442 params2.SetMeid("RAN_NAME_1")
3443 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
3444 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
3446 //Req1 (retransmitted)
3447 e2termConn1.RecvSubsReq(t)
3449 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3451 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3452 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3454 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3455 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3456 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3457 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3460 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3463 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
3465 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
3467 //Wait that subs is cleaned
3468 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
3470 mainCtrl.VerifyCounterValues(t)
3473 //-----------------------------------------------------------------------------
3474 // TestRESTSubReqAndSubDelNokSameActionParallel
3477 // +-------+ +-------+ +---------+ +---------+
3478 // | xapp2 | | xapp1 | | submgr | | e2term |
3479 // +-------+ +-------+ +---------+ +---------+
3483 // | | RESTSubReq1 | |
3484 // | |---------------->| |
3486 // | | RESTSubResp1 | |
3487 // | |<----------------| |
3489 // | | |------------->|
3490 // | RESTSubReq2 | |
3491 // |------------------------------>| |
3493 // | RESTSubDelResp2 | |
3494 // |<------------------------------| |
3496 // | | |<-------------|
3498 // | | RESTNotif1 | |
3499 // | | unsuccess | |
3500 // | |<----------------| |
3502 // | | unsuccess | |
3503 // |<------------------------------| |
3504 // | | | SubDelReq |
3505 // | | |------------->|
3506 // | | | SubDelResp |
3507 // | | |<-------------|
3509 // | | RESTSubDelReq1 | |
3510 // | |---------------->| |
3512 // | | RESTSubDelResp1 | |
3513 // | |<----------------| |
3515 // | RESTSubDelReq2 | |
3516 // |------------------------------>| |
3518 // | RESTSubDelResp2 | |
3519 // |<------------------------------| |
3521 //-----------------------------------------------------------------------------
3522 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
3523 CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
3525 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3526 Counter{cSubReqFromXapp, 2},
3527 Counter{cSubReqToE2, 1},
3528 Counter{cSubFailFromE2, 1},
3529 Counter{cSubRespToXapp, 2},
3530 Counter{cSubDelReqFromXapp, 2},
3531 Counter{cSubDelReqToE2, 1},
3532 Counter{cSubDelRespFromE2, 1},
3533 Counter{cSubDelRespToXapp, 2},
3536 const subReqCount int = 1
3537 const parameterSet = 1
3538 const actionDefinitionPresent bool = true
3539 const actionParamCount int = 1
3542 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3543 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3544 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3547 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
3548 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3549 params2.SetMeid("RAN_NAME_1")
3550 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
3551 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
3553 // E2t: send SubsFail (first)
3554 fparams1 := &teststube2ap.E2StubSubsFailParams{}
3555 fparams1.Set(crereq1)
3556 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3558 // E2t: internal delete
3559 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3560 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3561 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3563 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3564 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3565 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3566 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3569 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3572 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
3574 //Wait that subs is cleaned
3575 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
3576 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
3578 mainCtrl.VerifyCounterValues(t)
3581 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
3582 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
3584 // Init counter check
3585 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3586 Counter{cSubReqFromXapp, 1},
3587 Counter{cSubReqToE2, 1},
3588 Counter{cSubRespFromE2, 1},
3589 Counter{cSubRespToXapp, 1},
3590 Counter{cSubDelReqFromXapp, 1},
3591 Counter{cSubDelReqToE2, 1},
3592 Counter{cSubDelRespFromE2, 1},
3593 Counter{cSubDelRespToXapp, 1},
3596 const subReqCount int = 1
3597 const parameterSet = 1
3598 const actionDefinitionPresent bool = true
3599 const actionParamCount int = 1
3601 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
3602 restSubId := xappConn1.SendRESTSubsReq(t, params)
3603 xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
3605 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3606 xappConn1.ExpectRESTNotification(t, restSubId)
3607 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3608 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3609 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
3611 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3612 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3613 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3615 // Wait that subs is cleaned
3616 waitSubsCleanup(t, e2SubsId, 10)
3617 mainCtrl.VerifyCounterValues(t)
3620 //-----------------------------------------------------------------------------
3621 // TestRESTSubReqPolicyChangeAndSubDelOk
3624 // +-------+ +---------+ +---------+
3625 // | xapp | | submgr | | e2term |
3626 // +-------+ +---------+ +---------+
3629 // |---------------->| |
3631 // | RESTSubResp | |
3632 // |<----------------| |
3634 // | |------------->|
3637 // | |<-------------|
3640 // |<----------------| |
3643 // |---------------->| |
3645 // | RESTSubResp | |
3646 // |<----------------| |
3648 // | |------------->|
3651 // | |<-------------|
3654 // |<----------------| |
3656 // | RESTSubDelReq | |
3657 // |---------------->| |
3660 // | |------------->|
3663 // | |<-------------|
3665 // | RESTSubDelResp | |
3666 // |<----------------| |
3668 //-----------------------------------------------------------------------------
3669 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
3670 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
3672 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3673 Counter{cSubReqFromXapp, 2},
3674 Counter{cSubReqToE2, 2},
3675 Counter{cSubRespFromE2, 2},
3676 Counter{cSubRespToXapp, 2},
3677 Counter{cSubDelReqFromXapp, 1},
3678 Counter{cSubDelReqToE2, 1},
3679 Counter{cSubDelRespFromE2, 1},
3680 Counter{cSubDelRespToXapp, 1},
3683 const subReqCount int = 1
3684 const parameterSet = 1
3685 const actionDefinitionPresent bool = true
3686 const policyParamCount int = 1
3689 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
3690 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3693 instanceId := int64(e2SubsId)
3694 // GetRESTSubsReqPolicyParams sets some coutners on tc side.
3695 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
3696 params.SubsReqParams.SubscriptionDetails[0].InstanceID = &instanceId
3697 params.SetTimeToWait("w200ms")
3698 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
3701 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3703 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3704 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3706 // Wait that subs is cleaned
3707 waitSubsCleanup(t, e2SubsId, 10)
3708 mainCtrl.VerifyCounterValues(t)
3711 //-----------------------------------------------------------------------------
3712 // TestRESTSubReqAndSubDelOkTwoE2termParallel
3715 // +-------+ +---------+ +---------+ +---------+
3716 // | xapp | | submgr | | e2term1 | | e2term2 |
3717 // +-------+ +---------+ +---------+ +---------+
3721 // | RESTSubReq1 | | |
3722 // |---------------->| | |
3724 // | RESTSubResp1 | | |
3725 // |<----------------| | |
3727 // | |------------->| |
3729 // | RESTSubReq2 | | |
3730 // |---------------->| | |
3732 // | RESTSubResp2 | | |
3733 // |<----------------| | |
3735 // | |---------------------------->|
3738 // | |<-------------| |
3739 // | RESTNotif1 | | |
3740 // |<----------------| | |
3742 // | |<----------------------------|
3743 // | RESTNotif2 | | |
3744 // |<----------------| | |
3746 // | [SUBS 1 DELETE] | |
3748 // | [SUBS 2 DELETE] | |
3751 //-----------------------------------------------------------------------------
3752 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
3753 CaseBegin("TestRESTSubReqAndSubDelOkTwoE2termParallel")
3755 // Init counter check
3756 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3757 Counter{cSubReqFromXapp, 2},
3758 Counter{cSubReqToE2, 2},
3759 Counter{cSubRespFromE2, 2},
3760 Counter{cSubRespToXapp, 2},
3761 Counter{cSubDelReqFromXapp, 2},
3762 Counter{cSubDelReqToE2, 2},
3763 Counter{cSubDelRespFromE2, 2},
3764 Counter{cSubDelRespToXapp, 2},
3767 const subReqCount int = 1
3768 const parameterSet = 1
3769 const actionDefinitionPresent bool = true
3770 const actionParamCount int = 1
3773 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3774 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3775 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3778 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3779 params.SetMeid("RAN_NAME_11")
3780 // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
3781 // would not work as notification would not be received
3782 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3783 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
3786 xappConn1.ExpectRESTNotification(t, restSubId1)
3787 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3788 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
3789 xapp.Logger.Info("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
3792 xappConn2.ExpectRESTNotification(t, restSubId2)
3793 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
3794 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
3795 xapp.Logger.Info("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
3798 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3799 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3800 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3802 // Wait that subs is cleaned
3803 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3806 xappConn1.SendRESTSubsDelReq(t, &restSubId2)
3807 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
3808 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
3810 // Wait that subs is cleaned
3811 waitSubsCleanup(t, e2SubsId2, 10)
3813 mainCtrl.VerifyCounterValues(t)
3816 //-----------------------------------------------------------------------------
3817 // TestRESTSubReqAsn1EncodeFail
3819 // In this case submgr send RICSubscriptionDeleteRequest after encode failure which should not happen!
3821 // +-------+ +---------+ +---------+
3822 // | xapp | | submgr | | e2term |
3823 // +-------+ +---------+ +---------+
3826 // |---------------->| |
3828 // | RESTSubResp | |
3829 // |<----------------| |
3830 // | RESTSubDelReq | |
3831 // |---------------->| |
3832 // | RESTSubDelResp | |
3834 // |<----------------| |
3837 //-----------------------------------------------------------------------------
3838 func TestRESTSubReqAsn1EncodeFail(t *testing.T) {
3839 CaseBegin("TestRESTSubReqAsn1EncodeFail")
3841 xapp.Logger.Info("Xapp-frame, v0.8.1 sufficient REST API validation")
3845 //-----------------------------------------------------------------------------
3846 // TestRESTSubReqInsertAndSubDelOk
3849 // +-------+ +---------+ +---------+
3850 // | xapp | | submgr | | e2term |
3851 // +-------+ +---------+ +---------+
3854 // |---------------->| |
3856 // | RESTSubResp | |
3857 // |<----------------| |
3860 // | |------------->|
3863 // | |<-------------|
3865 // |<----------------| |
3868 // | RESTSubDelReq | |
3869 // |---------------->| |
3872 // | |------------->|
3875 // | |<-------------|
3877 // | RESTSubDelResp| |
3878 // |<----------------| |
3880 //-----------------------------------------------------------------------------
3881 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
3882 CaseBegin("TestRESTInsertSubReqAndSubDelOk")
3884 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3885 Counter{cSubReqFromXapp, 1},
3886 Counter{cSubReqToE2, 1},
3887 Counter{cSubRespFromE2, 1},
3888 Counter{cSubRespToXapp, 1},
3889 Counter{cSubDelReqFromXapp, 1},
3890 Counter{cSubDelReqToE2, 1},
3891 Counter{cSubDelRespFromE2, 1},
3892 Counter{cSubDelRespToXapp, 1},
3895 const subReqCount int = 1
3896 const parameterSet int = 1
3897 const actionDefinitionPresent bool = true
3898 const actionParamCount int = 1
3900 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3901 params.SetSubActionTypes("insert")
3904 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3907 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3909 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3910 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3912 // Wait that subs is cleaned
3913 waitSubsCleanup(t, e2SubsId, 10)
3914 mainCtrl.VerifyCounterValues(t)
3917 //-----------------------------------------------------------------------------
3918 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
3921 // +-------+ +---------+ +---------+
3922 // | xapp | | submgr | | e2term |
3923 // +-------+ +---------+ +---------+
3926 // |------------->| |
3929 // | |------------->|
3934 // | Submgr restart |
3938 // | |------------->|
3941 // | |<-------------|
3944 //-----------------------------------------------------------------------------
3945 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
3946 CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle")
3948 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3949 Counter{cSubReqFromXapp, 1},
3950 Counter{cSubReqToE2, 1},
3951 Counter{cSubDelReqFromXapp, 1},
3952 Counter{cSubDelReqToE2, 1},
3953 Counter{cSubDelRespFromE2, 1},
3956 const subReqCount int = 1
3957 const parameterSet = 1
3958 const actionDefinitionPresent bool = true
3959 const actionParamCount int = 1
3961 // Remove possible existing subscription
3962 mainCtrl.removeExistingSubscriptions(t)
3964 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3967 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
3968 restSubId := xappConn1.SendRESTSubsReq(t, params)
3969 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
3971 e2termConn1.RecvSubsReq(t)
3973 mainCtrl.SetResetTestFlag(t, false)
3975 mainCtrl.SimulateRestart(t)
3976 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
3979 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3980 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3982 xappConn1.TestMsgChanEmpty(t)
3983 xappConn2.TestMsgChanEmpty(t)
3984 e2termConn1.TestMsgChanEmpty(t)
3985 mainCtrl.wait_registry_empty(t, 10)
3987 mainCtrl.VerifyCounterValues(t)
3990 //-----------------------------------------------------------------------------
3991 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
3994 // +-------+ +---------+ +---------+
3995 // | xapp | | submgr | | e2term |
3996 // +-------+ +---------+ +---------+
3999 // |---------------->| |
4001 // | RESTSubResp | |
4002 // |<----------------| |
4004 // | |------------->|
4007 // | |<-------------|
4010 // |<----------------| |
4013 // | Submgr restart |
4015 // | RESTSubDelReq | |
4016 // |---------------->| |
4019 // | |------------->|
4022 // | |<-------------|
4024 // | RESTSubDelResp | |
4025 // |<----------------| |
4027 //-----------------------------------------------------------------------------
4028 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
4029 CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle")
4031 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4032 Counter{cSubReqFromXapp, 1},
4033 Counter{cSubReqToE2, 1},
4034 Counter{cSubRespFromE2, 1},
4035 Counter{cSubRespToXapp, 1},
4036 Counter{cSubDelReqFromXapp, 1},
4037 Counter{cSubDelReqToE2, 1},
4038 Counter{cSubDelRespToXapp, 1},
4041 // Remove possible existing subscription
4042 mainCtrl.removeExistingSubscriptions(t)
4044 var params *teststube2ap.RESTSubsReqParams = nil
4046 // Create subscription
4047 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4048 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
4050 // Check subscription
4051 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4053 // When SDL support for the REST Interface is added
4054 // the submgr restart statement below should be removed
4055 // from the comment.
4057 // mainCtrl.SimulateRestart(t)
4058 // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4060 // Check subscription
4061 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4063 // Delete subscription
4064 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
4066 //Wait that subs is cleaned
4067 waitSubsCleanup(t, e2SubsId, 10)
4069 mainCtrl.VerifyCounterValues(t)
4072 //-----------------------------------------------------------------------------
4073 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
4076 // +-------+ +-------+ +---------+ +---------+
4077 // | xapp2 | | xapp1 | | submgr | | e2term |
4078 // +-------+ +-------+ +---------+ +---------+
4080 // | | RESTSubReq1 | |
4081 // | |---------------->| |
4083 // | | RESTSubResp1 | |
4084 // | |<----------------| |
4087 // | | |------------->|
4089 // | | |<-------------|
4090 // | | RESTNotif1 | |
4091 // | |<----------------| |
4093 // | RESTSubReq2 | |
4094 // |------------------------------>| |
4096 // | RESTSubResp2 | |
4097 // |<------------------------------| |
4099 // | | RESTNotif2 | |
4100 // |<------------------------------| |
4102 // | | Submgr restart |
4104 // | | RESTSubDelReq1 | |
4105 // | |---------------->| |
4107 // | | RESTSubDelResp1 | |
4108 // | |<----------------| |
4110 // | | Submgr restart |
4112 // | RESTSubDelReq2 | |
4113 // |------------------------------>| |
4115 // | RESTSubDelResp2 | |
4116 // |<------------------------------| |
4118 // | | | SubDelReq2 |
4119 // | | |------------->|
4121 // | | | SubDelResp2 |
4122 // | | |<-------------|
4125 //-----------------------------------------------------------------------------
4126 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
4127 CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
4129 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4130 Counter{cSubReqFromXapp, 2},
4131 Counter{cSubReqToE2, 1},
4132 Counter{cSubRespFromE2, 1},
4133 Counter{cSubRespToXapp, 2},
4134 Counter{cMergedSubscriptions, 1},
4135 Counter{cUnmergedSubscriptions, 1},
4136 Counter{cSubDelReqFromXapp, 2},
4137 Counter{cSubDelReqToE2, 1},
4138 Counter{cSubDelRespFromE2, 1},
4139 Counter{cSubDelRespToXapp, 2},
4142 // Remove possible existing subscription
4143 mainCtrl.removeExistingSubscriptions(t)
4145 var params *teststube2ap.RESTSubsReqParams = nil
4147 // Create subscription 1
4148 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4149 xapp.Logger.Info("Send REST subscriber request for subscriber 1 : %v", restSubId1)
4151 // Create subscription 2 with same action
4152 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4153 params.SetMeid("RAN_NAME_1")
4154 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4155 xappConn2.WaitRESTNotificationForAnySubscriptionId(t)
4156 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4157 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4158 e2SubsId2 := <-xappConn2.RESTNotification
4159 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
4161 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
4163 // When SDL support for the REST Interface is added
4164 // the submgr restart statement below should be removed
4165 // from the comment.
4167 // mainCtrl.SimulateRestart(t)
4168 // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4170 // Delete subscription 1
4171 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4173 // When SDL support for the REST Interface is added
4174 // the submgr restart statement below should be removed
4175 // from the comment.
4177 // mainCtrl.SimulateRestart(t)
4178 // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4180 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
4182 // Delete subscription 2
4183 deleteXapp2Subscription(t, &restSubId2)
4185 //Wait that subs is cleaned
4186 waitSubsCleanup(t, e2SubsId2, 10)
4188 mainCtrl.VerifyCounterValues(t)
4191 //-----------------------------------------------------------------------------
4192 // TestRESTReportSubReqAndSubDelOk
4195 // +-------+ +---------+ +---------+
4196 // | xapp | | submgr | | e2term |
4197 // +-------+ +---------+ +---------+
4200 // |---------------->| |
4202 // | RESTSubResp | |
4203 // |<----------------| |
4206 // | |------------->|
4209 // | |<-------------|
4211 // |<----------------| |
4213 // | |------------->|
4216 // | |<-------------|
4218 // |<----------------| |
4222 // | RESTSubDelReq | |
4223 // |---------------->| |
4226 // | |------------->|
4229 // | |<-------------|
4231 // | RESTSubDelResp| |
4232 // |<----------------| |
4234 //-----------------------------------------------------------------------------
4235 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
4236 CaseBegin("TestRESTReportSubReqAndSubDelOk")
4238 parameterSet := 1 // E2SM-gNB-X2
4239 actionDefinitionPresent := true
4240 actionParamCount := 1
4242 RESTReportSubReqAndSubDelOk(t, subReqCount, parameterSet, actionDefinitionPresent, actionParamCount, testIndex)
4245 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, parameterSet int, actionDefinitionPresent bool, actionParamCount int, testIndex int) {
4246 xapp.Logger.Info("TEST: TestRESTReportSubReqAndSubDelOk with parameter set %v", testIndex)
4249 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4250 restSubId := xappConn1.SendRESTSubsReq(t, params)
4252 var e2SubsId []uint32
4253 for i := 0; i < subReqCount; i++ {
4254 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4255 xappConn1.ExpectRESTNotification(t, restSubId)
4257 e2termConn1.SendSubsResp(t, crereq, cremsg)
4258 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
4259 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
4260 e2SubsId = append(e2SubsId, instanceId)
4261 resp, _ := xapp.Subscription.QuerySubscriptions()
4262 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
4263 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
4264 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
4269 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4271 for i := 0; i < subReqCount; i++ {
4272 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4273 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4276 // Wait that subs is cleaned
4277 for i := 0; i < subReqCount; i++ {
4278 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
4281 xappConn1.TestMsgChanEmpty(t)
4282 e2termConn1.TestMsgChanEmpty(t)
4283 mainCtrl.wait_registry_empty(t, 10)
4287 func TestRESTPolicySubReqAndSubDelOk(t *testing.T) {
4288 CaseBegin("TestRESTPolicySubReqAndSubDelOk")
4291 actionDefinitionPresent := true
4292 policyParamCount := 1
4294 RESTPolicySubReqAndSubDelOk(t, subReqCount, actionDefinitionPresent, policyParamCount, testIndex)
4297 actionDefinitionPresent = false
4298 policyParamCount = 0
4300 RESTPolicySubReqAndSubDelOk(t, subReqCount, actionDefinitionPresent, policyParamCount, testIndex)
4303 func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, actionDefinitionPresent bool, policyParamCount int, testIndex int) {
4304 xapp.Logger.Info("TEST: TestRESTPolicySubReqAndSubDelOk with parameter set %v", testIndex)
4307 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
4308 restSubId := xappConn1.SendRESTSubsReq(t, params)
4309 //params := xappConn1.GetRESTSubsReqPolicyParams1(subReqCount, actionDefinitionPresent, policyParamCount)
4310 //restSubId := xappConn1.SendRESTPolicySubsReq(t, params)
4312 var e2SubsId []uint32
4313 for i := 0; i < subReqCount; i++ {
4314 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4315 xappConn1.ExpectRESTNotification(t, restSubId)
4316 e2termConn1.SendSubsResp(t, crereq, cremsg)
4317 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
4318 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
4319 e2SubsId = append(e2SubsId, instanceId)
4323 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4325 for i := 0; i < subReqCount; i++ {
4326 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4327 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4330 // Wait that subs is cleaned
4331 for i := 0; i < subReqCount; i++ {
4332 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
4334 xappConn1.TestMsgChanEmpty(t)
4335 e2termConn1.TestMsgChanEmpty(t)
4336 mainCtrl.wait_registry_empty(t, 10)
4339 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
4343 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4344 Counter{cSubReqFromXapp, 1},
4345 Counter{cSubReqToE2, 2},
4346 Counter{cSubRespFromE2, 2},
4347 Counter{cSubRespToXapp, 2},
4348 Counter{cSubDelReqFromXapp, 1},
4349 Counter{cSubDelReqToE2, 2},
4350 Counter{cSubDelRespFromE2, 2},
4351 Counter{cSubDelRespToXapp, 1},
4355 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
4356 restSubId := xappConn1.SendRESTSubsReq(t, params)
4357 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4359 assert.Equal(t, len(e2SubsIds), 2)
4362 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4363 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4365 xappConn1.TestMsgChanEmpty(t)
4366 e2termConn1.TestMsgChanEmpty(t)
4367 mainCtrl.wait_registry_empty(t, 10)
4369 mainCtrl.VerifyCounterValues(t)
4371 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
4375 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4376 Counter{cSubReqFromXapp, 1},
4377 Counter{cSubReqToE2, 19},
4378 Counter{cSubRespFromE2, 19},
4379 Counter{cSubRespToXapp, 19},
4380 Counter{cSubDelReqFromXapp, 1},
4381 Counter{cSubDelReqToE2, 19},
4382 Counter{cSubDelRespFromE2, 19},
4383 Counter{cSubDelRespToXapp, 1},
4387 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
4388 restSubId := xappConn1.SendRESTSubsReq(t, params)
4389 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4391 assert.Equal(t, len(e2SubsIds), 19)
4393 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4394 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4396 xappConn1.TestMsgChanEmpty(t)
4397 e2termConn1.TestMsgChanEmpty(t)
4398 mainCtrl.wait_registry_empty(t, 10)
4400 mainCtrl.VerifyCounterValues(t)
4402 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
4406 actionDefinitionPresent := true
4407 actionParamCount := 1
4409 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4410 Counter{cSubReqFromXapp, 1},
4411 Counter{cSubReqToE2, uint64(subReqCount)},
4412 Counter{cSubRespFromE2, uint64(subReqCount)},
4413 Counter{cSubRespToXapp, uint64(subReqCount)},
4414 Counter{cSubDelReqFromXapp, 1},
4415 Counter{cSubDelReqToE2, uint64(subReqCount)},
4416 Counter{cSubDelRespFromE2, uint64(subReqCount)},
4417 Counter{cSubDelRespToXapp, 1},
4421 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4422 restSubId := xappConn1.SendRESTSubsReq(t, params)
4423 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4425 assert.Equal(t, len(e2SubsIds), subReqCount)
4428 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4429 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4431 xappConn1.TestMsgChanEmpty(t)
4432 e2termConn1.TestMsgChanEmpty(t)
4433 mainCtrl.wait_registry_empty(t, 10)
4435 mainCtrl.VerifyCounterValues(t)
4439 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
4443 actionDefinitionPresent := false
4444 actionParamCount := 0
4446 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4447 Counter{cSubReqFromXapp, 1},
4448 Counter{cSubReqToE2, uint64(subReqCount)},
4449 Counter{cSubRespFromE2, uint64(subReqCount)},
4450 Counter{cSubRespToXapp, uint64(subReqCount)},
4451 Counter{cSubDelReqFromXapp, 1},
4452 Counter{cSubDelReqToE2, uint64(subReqCount)},
4453 Counter{cSubDelRespFromE2, uint64(subReqCount)},
4454 Counter{cSubDelRespToXapp, 1},
4458 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4459 restSubId := xappConn1.SendRESTSubsReq(t, params)
4460 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4462 assert.Equal(t, len(e2SubsIds), subReqCount)
4465 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4466 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4468 xappConn1.TestMsgChanEmpty(t)
4469 e2termConn1.TestMsgChanEmpty(t)
4470 mainCtrl.wait_registry_empty(t, 10)
4472 mainCtrl.VerifyCounterValues(t)
4476 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
4480 actionDefinitionPresent := false
4481 actionParamCount := 0
4483 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4484 Counter{cSubReqFromXapp, 1},
4485 Counter{cSubReqToE2, uint64(subReqCount)},
4486 Counter{cSubRespFromE2, uint64(subReqCount)},
4487 Counter{cSubRespToXapp, uint64(subReqCount)},
4488 Counter{cSubDelReqFromXapp, 1},
4489 Counter{cSubDelReqToE2, uint64(subReqCount)},
4490 Counter{cSubDelRespFromE2, uint64(subReqCount)},
4491 Counter{cSubDelRespToXapp, 1},
4495 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4496 restSubId := xappConn1.SendRESTSubsReq(t, params)
4497 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4499 assert.Equal(t, len(e2SubsIds), subReqCount)
4502 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4503 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4505 xappConn1.TestMsgChanEmpty(t)
4506 e2termConn1.TestMsgChanEmpty(t)
4507 mainCtrl.wait_registry_empty(t, 10)
4509 mainCtrl.VerifyCounterValues(t)
4513 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
4514 CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
4516 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4517 Counter{cSubReqFromXapp, 2},
4518 Counter{cSubReqToE2, 2},
4519 Counter{cSubRespFromE2, 2},
4520 Counter{cSubRespToXapp, 2},
4521 Counter{cSubDelReqFromXapp, 2},
4522 Counter{cSubDelReqToE2, 2},
4523 Counter{cSubDelRespFromE2, 2},
4524 Counter{cSubDelRespToXapp, 2},
4528 var params *teststube2ap.RESTSubsReqParams = nil
4531 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4532 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4534 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4537 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4538 params.SetMeid("RAN_NAME_1")
4539 eventTriggerDefinition := "1234"
4540 params.SetSubEventTriggerDefinition(eventTriggerDefinition)
4542 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4543 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4544 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4545 xappConn2.ExpectRESTNotification(t, restSubId2)
4546 e2termConn1.SendSubsResp(t, crereq, cremsg)
4547 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4549 deleteXapp1Subscription(t, &restSubId1)
4550 deleteXapp2Subscription(t, &restSubId2)
4552 waitSubsCleanup(t, e2SubsId1, 10)
4553 waitSubsCleanup(t, e2SubsId2, 10)
4555 mainCtrl.VerifyCounterValues(t)
4559 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
4560 CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
4562 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4563 Counter{cSubReqFromXapp, 2},
4564 Counter{cSubReqToE2, 2},
4565 Counter{cSubRespFromE2, 2},
4566 Counter{cSubRespToXapp, 2},
4567 Counter{cSubDelReqFromXapp, 2},
4568 Counter{cSubDelReqToE2, 2},
4569 Counter{cSubDelRespFromE2, 2},
4570 Counter{cSubDelRespToXapp, 2},
4574 var params *teststube2ap.RESTSubsReqParams = nil
4577 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4578 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4580 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4583 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4584 params.SetMeid("RAN_NAME_1")
4586 actionId := int64(1)
4587 actionType := "report"
4588 actionDefinition := "56781"
4589 subsequestActionType := "continue"
4590 timeToWait := "w10ms"
4591 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
4593 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4594 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4595 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4596 xappConn2.ExpectRESTNotification(t, restSubId2)
4597 e2termConn1.SendSubsResp(t, crereq, cremsg)
4598 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4600 deleteXapp1Subscription(t, &restSubId1)
4601 deleteXapp2Subscription(t, &restSubId2)
4603 waitSubsCleanup(t, e2SubsId1, 10)
4604 waitSubsCleanup(t, e2SubsId2, 10)
4606 mainCtrl.VerifyCounterValues(t)
4610 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
4611 CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
4613 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4614 Counter{cSubReqFromXapp, 2},
4615 Counter{cSubReqToE2, 2},
4616 Counter{cSubRespFromE2, 2},
4617 Counter{cSubRespToXapp, 2},
4618 Counter{cSubDelReqFromXapp, 2},
4619 Counter{cSubDelReqToE2, 2},
4620 Counter{cSubDelRespFromE2, 2},
4621 Counter{cSubDelRespToXapp, 2},
4625 var params *teststube2ap.RESTSubsReqParams = nil
4628 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4629 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4631 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4634 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4635 params.SetMeid("RAN_NAME_1")
4636 params.SetSubActionIDs(int64(2))
4638 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4639 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4640 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4641 xappConn2.ExpectRESTNotification(t, restSubId2)
4642 e2termConn1.SendSubsResp(t, crereq, cremsg)
4643 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4645 deleteXapp1Subscription(t, &restSubId1)
4646 deleteXapp2Subscription(t, &restSubId2)
4648 waitSubsCleanup(t, e2SubsId1, 10)
4649 waitSubsCleanup(t, e2SubsId2, 10)
4651 mainCtrl.VerifyCounterValues(t)
4655 func TestRESTSubReqDiffActionType(t *testing.T) {
4656 CaseBegin("TestRESTSubReqDiffActionType")
4658 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4659 Counter{cSubReqFromXapp, 2},
4660 Counter{cSubReqToE2, 2},
4661 Counter{cSubRespFromE2, 2},
4662 Counter{cSubRespToXapp, 2},
4663 Counter{cSubDelReqFromXapp, 2},
4664 Counter{cSubDelReqToE2, 2},
4665 Counter{cSubDelRespFromE2, 2},
4666 Counter{cSubDelRespToXapp, 2},
4670 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
4673 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4674 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4676 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4679 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4680 params.SetMeid("RAN_NAME_1")
4682 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4683 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4684 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4685 xappConn2.ExpectRESTNotification(t, restSubId2)
4686 e2termConn1.SendSubsResp(t, crereq, cremsg)
4687 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4689 deleteXapp1Subscription(t, &restSubId1)
4690 deleteXapp2Subscription(t, &restSubId2)
4692 waitSubsCleanup(t, e2SubsId1, 10)
4693 waitSubsCleanup(t, e2SubsId2, 10)
4695 mainCtrl.VerifyCounterValues(t)
4699 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
4700 CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
4702 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4703 Counter{cSubReqFromXapp, 2},
4704 Counter{cSubReqToE2, 2},
4705 Counter{cSubRespFromE2, 2},
4706 Counter{cSubRespToXapp, 2},
4707 Counter{cSubDelReqFromXapp, 2},
4708 Counter{cSubDelReqToE2, 2},
4709 Counter{cSubDelRespFromE2, 2},
4710 Counter{cSubDelRespToXapp, 2},
4714 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
4717 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4718 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4720 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4723 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
4724 params.SetMeid("RAN_NAME_1")
4726 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4727 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4728 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4729 xappConn2.ExpectRESTNotification(t, restSubId2)
4730 e2termConn1.SendSubsResp(t, crereq, cremsg)
4731 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4733 deleteXapp1Subscription(t, &restSubId1)
4734 deleteXapp2Subscription(t, &restSubId2)
4736 waitSubsCleanup(t, e2SubsId1, 10)
4737 waitSubsCleanup(t, e2SubsId2, 10)
4739 mainCtrl.VerifyCounterValues(t)
4743 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
4744 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
4746 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4747 Counter{cSubReqFromXapp, 2},
4748 Counter{cSubReqToE2, 2},
4749 Counter{cSubRespFromE2, 2},
4750 Counter{cSubRespToXapp, 2},
4751 Counter{cSubDelReqFromXapp, 2},
4752 Counter{cSubDelReqToE2, 2},
4753 Counter{cSubDelRespFromE2, 2},
4754 Counter{cSubDelRespToXapp, 2},
4758 var params *teststube2ap.RESTSubsReqParams = nil
4761 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4762 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4764 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4767 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4768 params.SetMeid("RAN_NAME_1")
4769 actionDefinition := "5678"
4770 params.SetSubActionDefinition(actionDefinition)
4772 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4773 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4774 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4775 xappConn2.ExpectRESTNotification(t, restSubId2)
4776 e2termConn1.SendSubsResp(t, crereq, cremsg)
4777 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4779 deleteXapp1Subscription(t, &restSubId1)
4780 deleteXapp2Subscription(t, &restSubId2)
4782 waitSubsCleanup(t, e2SubsId1, 10)
4783 waitSubsCleanup(t, e2SubsId2, 10)
4785 mainCtrl.VerifyCounterValues(t)
4789 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
4790 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
4792 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4793 Counter{cSubReqFromXapp, 2},
4794 Counter{cSubReqToE2, 2},
4795 Counter{cSubRespFromE2, 2},
4796 Counter{cSubRespToXapp, 2},
4797 Counter{cSubDelReqFromXapp, 2},
4798 Counter{cSubDelReqToE2, 2},
4799 Counter{cSubDelRespFromE2, 2},
4800 Counter{cSubDelRespToXapp, 2},
4804 var params *teststube2ap.RESTSubsReqParams = nil
4807 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4808 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4810 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4813 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4814 params.SetMeid("RAN_NAME_1")
4815 actionDefinition := "56782"
4816 params.SetSubActionDefinition(actionDefinition)
4818 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4819 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4820 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4821 xappConn2.ExpectRESTNotification(t, restSubId2)
4822 e2termConn1.SendSubsResp(t, crereq, cremsg)
4823 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4825 deleteXapp1Subscription(t, &restSubId1)
4826 deleteXapp2Subscription(t, &restSubId2)
4828 waitSubsCleanup(t, e2SubsId1, 10)
4829 waitSubsCleanup(t, e2SubsId2, 10)
4831 mainCtrl.VerifyCounterValues(t)
4835 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
4836 CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
4838 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4839 Counter{cSubReqFromXapp, 2},
4840 Counter{cSubReqToE2, 2},
4841 Counter{cSubRespFromE2, 2},
4842 Counter{cSubRespToXapp, 2},
4843 Counter{cSubDelReqFromXapp, 2},
4844 Counter{cSubDelReqToE2, 2},
4845 Counter{cSubDelRespFromE2, 2},
4846 Counter{cSubDelRespToXapp, 2},
4850 var params *teststube2ap.RESTSubsReqParams = nil
4853 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4854 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4856 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4859 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4860 params.SetMeid("RAN_NAME_1")
4861 params.SetTimeToWait("w200ms")
4862 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4863 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4864 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4865 xappConn2.ExpectRESTNotification(t, restSubId2)
4866 e2termConn1.SendSubsResp(t, crereq, cremsg)
4867 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4869 deleteXapp1Subscription(t, &restSubId1)
4870 deleteXapp2Subscription(t, &restSubId2)
4872 waitSubsCleanup(t, e2SubsId1, 10)
4873 waitSubsCleanup(t, e2SubsId2, 10)
4875 mainCtrl.VerifyCounterValues(t)
4879 ////////////////////////////////////////////////////////////////////////////////////
4880 // Services for UT cases
4881 ////////////////////////////////////////////////////////////////////////////////////
4882 const subReqCount int = 1
4883 const parameterSet = 1
4884 const actionDefinitionPresent bool = true
4885 const actionParamCount int = 1
4886 const policyParamCount int = 1
4887 const host string = "localhost"
4889 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
4891 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4893 restSubId := fromXappConn.SendRESTSubsReq(t, params)
4894 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
4896 crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
4897 fromXappConn.ExpectRESTNotification(t, restSubId)
4898 toE2termConn.SendSubsResp(t, crereq1, cremsg1)
4899 e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
4900 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
4902 return restSubId, e2SubsId
4905 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
4907 params := xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4909 params.SetMeid(meid)
4911 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4912 restSubId := xappConn2.SendRESTSubsReq(t, params)
4913 xappConn2.ExpectRESTNotification(t, restSubId)
4914 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
4915 e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
4916 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
4918 return restSubId, e2SubsId
4921 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
4922 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
4923 restSubId := xappConn1.SendRESTSubsReq(t, params)
4924 xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
4926 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4927 xappConn1.ExpectRESTNotification(t, restSubId)
4928 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4929 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4930 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
4932 return restSubId, e2SubsId
4935 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
4936 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4937 restSubId := xappConn1.SendRESTSubsReq(t, params)
4939 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4940 fparams1 := &teststube2ap.E2StubSubsFailParams{}
4941 fparams1.Set(crereq1)
4942 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
4944 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4945 xappConn1.ExpectRESTNotification(t, restSubId)
4946 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4947 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4948 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
4950 return restSubId, e2SubsId
4953 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
4954 fromXappConn.SendRESTSubsDelReq(t, restSubId)
4955 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
4956 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
4959 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
4960 xappConn1.SendRESTSubsDelReq(t, restSubId)
4961 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4962 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4965 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
4966 xappConn2.SendRESTSubsDelReq(t, restSubId)
4967 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4968 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4971 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
4972 resp, _ := xapp.Subscription.QuerySubscriptions()
4973 assert.Equal(t, resp[0].SubscriptionID, e2SubsId)
4974 assert.Equal(t, resp[0].Meid, meid)
4975 assert.Equal(t, resp[0].ClientEndpoint, endpoint)
4978 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
4979 //Wait that subs is cleaned
4980 mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
4982 xappConn1.TestMsgChanEmpty(t)
4983 xappConn2.TestMsgChanEmpty(t)
4984 e2termConn1.TestMsgChanEmpty(t)
4985 mainCtrl.wait_registry_empty(t, timeout)
4988 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
4990 var e2SubsId []uint32
4992 for i := 0; i < count; i++ {
4993 xapp.Logger.Info("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
4994 crereq, cremsg := toE2termConn.RecvSubsReq(t)
4995 fromXappConn.ExpectRESTNotification(t, restSubId)
4996 toE2termConn.SendSubsResp(t, crereq, cremsg)
4997 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
4998 e2SubsId = append(e2SubsId, instanceId)
4999 xapp.Logger.Info("TEST: %v", e2SubsId)
5000 xapp.Logger.Info("TEST: %d ===================================== END CRE ============================================", i+1)
5001 <-time.After(100 * time.Millisecond)
5006 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
5008 for i := 0; i < len(e2SubsIds); i++ {
5009 xapp.Logger.Info("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
5010 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
5011 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
5012 <-time.After(1 * time.Second)
5013 xapp.Logger.Info("TEST: %d ===================================== END DEL ============================================", i+1)
5014 <-time.After(100 * time.Millisecond)
5017 // Wait that subs is cleaned
5018 for i := 0; i < len(e2SubsIds); i++ {
5019 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)