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/e2ap/pkg/e2ap_wrapper"
28 "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststube2ap"
29 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
30 "github.com/stretchr/testify/assert"
33 func TestRESTSubReqAndDeleteOkWithE2apUtWrapper(t *testing.T) {
35 // The effect of this call shall endure thgough the UT suite!
36 // If this causes any issues, the previout interface can be restored
38 // SetPackerIf(e2ap_wrapper.NewAsn1E2APPacker())
40 SetPackerIf(e2ap_wrapper.NewUtAsn1E2APPacker())
42 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
44 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
46 waitSubsCleanup(t, e2SubsId, 10)
49 //-----------------------------------------------------------------------------
50 // TestSubReqAndRouteNok
53 // +-------+ +---------+ +---------+
54 // | xapp | | submgr | | rtmgr |
55 // +-------+ +---------+ +---------+
67 // | [SUBS INT DELETE] |
70 //-----------------------------------------------------------------------------
72 func TestSubReqAndRouteNok(t *testing.T) {
73 CaseBegin("TestSubReqAndRouteNok")
76 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
77 Counter{cSubReqFromXapp, 1},
78 Counter{cRouteCreateFail, 1},
81 waiter := rtmgrHttp.AllocNextEvent(false)
82 newSubsId := mainCtrl.get_registry_next_subid(t)
83 xappConn1.SendSubsReq(t, nil, nil)
86 //Wait that subs is cleaned
87 mainCtrl.wait_subs_clean(t, newSubsId, 10)
89 xappConn1.TestMsgChanEmpty(t)
90 xappConn2.TestMsgChanEmpty(t)
91 e2termConn1.TestMsgChanEmpty(t)
92 mainCtrl.wait_registry_empty(t, 10)
94 <-time.After(1 * time.Second)
95 mainCtrl.VerifyCounterValues(t)
98 //-----------------------------------------------------------------------------
99 // TestSubReqAndRouteUpdateNok
102 // +-------+ +-------+ +---------+ +---------+
103 // | xapp2 | | xapp1 | | submgr | | rtmgr |
104 // +-------+ +-------+ +---------+ +---------+
106 // | [SUBS CREATE] | |
110 // | SubReq (mergeable) | |
111 // |--------------------------->| | |
113 // | | | RouteUpdate |
114 // | | |------------->|
116 // | | | RouteUpdate |
117 // | | | status:400 |
118 // | | |<-------------|
120 // | [SUBS INT DELETE] | |
123 // | [SUBS DELETE] | |
126 func TestSubReqAndRouteUpdateNok(t *testing.T) {
127 CaseBegin("TestSubReqAndRouteUpdateNok")
129 // Init counter check
130 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
131 Counter{cSubReqFromXapp, 2},
132 Counter{cSubReqToE2, 1},
133 Counter{cSubRespFromE2, 1},
134 Counter{cSubRespToXapp, 1},
135 Counter{cRouteCreateUpdateFail, 1},
136 Counter{cSubDelReqFromXapp, 1},
137 Counter{cSubDelReqToE2, 1},
138 Counter{cSubDelRespFromE2, 1},
139 Counter{cSubDelRespToXapp, 1},
142 cretrans := xappConn1.SendSubsReq(t, nil, nil)
143 crereq, cremsg := e2termConn1.RecvSubsReq(t)
144 e2termConn1.SendSubsResp(t, crereq, cremsg)
145 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
147 resp, _ := xapp.Subscription.QuerySubscriptions()
148 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
149 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
150 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
152 waiter := rtmgrHttp.AllocNextEvent(false)
153 newSubsId := mainCtrl.get_registry_next_subid(t)
154 xappConn2.SendSubsReq(t, nil, nil)
157 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
158 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
160 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
161 xappConn1.RecvSubsDelResp(t, deltrans)
163 //Wait that subs is cleaned
164 mainCtrl.wait_subs_clean(t, newSubsId, 10)
165 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
167 xappConn1.TestMsgChanEmpty(t)
168 xappConn2.TestMsgChanEmpty(t)
169 e2termConn1.TestMsgChanEmpty(t)
170 mainCtrl.wait_registry_empty(t, 10)
172 mainCtrl.VerifyCounterValues(t)
175 //-----------------------------------------------------------------------------
176 // TestSubDelReqAndRouteDeleteNok
179 // +-------+ +---------+ +---------+ +---------+
180 // | xapp | | submgr | | e2term | | rtmgr |
181 // +-------+ +---------+ +---------+ +---------+
183 // | [SUBS CREATE] | |
188 // |------------->| | |
190 // | |------------->| |
192 // | |<-------------| |
194 // |<-------------| | |
195 // | | RouteDelete | |
196 // | |---------------------------->|
198 // | | RouteDelete | |
199 // | | status:400 | |
200 // | |<----------------------------|
202 func TestSubDelReqAndRouteDeleteNok(t *testing.T) {
203 CaseBegin("TestSubDelReqAndRouteDeleteNok")
205 // Init counter check
206 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
207 Counter{cSubReqFromXapp, 1},
208 Counter{cSubReqToE2, 1},
209 Counter{cSubRespFromE2, 1},
210 Counter{cSubRespToXapp, 1},
211 Counter{cSubDelReqFromXapp, 1},
212 Counter{cRouteDeleteFail, 1},
213 Counter{cSubDelReqToE2, 1},
214 Counter{cSubDelRespFromE2, 1},
215 Counter{cSubDelRespToXapp, 1},
218 cretrans := xappConn1.SendSubsReq(t, nil, nil)
219 crereq, cremsg := e2termConn1.RecvSubsReq(t)
220 e2termConn1.SendSubsResp(t, crereq, cremsg)
221 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
223 resp, _ := xapp.Subscription.QuerySubscriptions()
224 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
225 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
226 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
228 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
229 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
231 waiter := rtmgrHttp.AllocNextEvent(false)
232 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
235 xappConn1.RecvSubsDelResp(t, deltrans)
237 //Wait that subs is cleaned
238 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
240 xappConn1.TestMsgChanEmpty(t)
241 xappConn2.TestMsgChanEmpty(t)
242 e2termConn1.TestMsgChanEmpty(t)
243 mainCtrl.wait_registry_empty(t, 10)
245 mainCtrl.VerifyCounterValues(t)
248 //-----------------------------------------------------------------------------
249 // TestSubMergeDelAndRouteUpdateNok
251 // +-------+ +-------+ +---------+ +---------+
252 // | xapp2 | | xapp1 | | submgr | | e2term |
253 // +-------+ +-------+ +---------+ +---------+
258 // | |------------->| |
261 // | | |------------->|
263 // | | |<-------------|
265 // | |<-------------| |
268 // |--------------------------->| |
271 // |<---------------------------| |
273 // | | SubDelReq 1 | |
274 // | |------------->| |
275 // | | | RouteUpdate |
276 // | | |-----> rtmgr |
278 // | | | RouteUpdate |
279 // | | | status:400 |
280 // | | |<----- rtmgr |
282 // | | SubDelResp 1 | |
283 // | |<-------------| |
286 // |--------------------------->| |
288 // | | | SubDelReq 2 |
289 // | | |------------->|
291 // | | | SubDelReq 2 |
292 // | | |------------->|
294 // | SubDelResp 2 | |
295 // |<---------------------------| |
297 //-----------------------------------------------------------------------------
298 func TestSubMergeDelAndRouteUpdateNok(t *testing.T) {
299 CaseBegin("TestSubMergeDelAndRouteUpdateNok")
301 // Init counter check
302 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
303 Counter{cSubReqFromXapp, 2},
304 Counter{cSubReqToE2, 1},
305 Counter{cSubRespFromE2, 1},
306 Counter{cSubRespToXapp, 2},
307 Counter{cSubDelReqFromXapp, 2},
308 Counter{cRouteDeleteUpdateFail, 1},
309 Counter{cSubDelReqToE2, 1},
310 Counter{cSubDelRespFromE2, 1},
311 Counter{cSubDelRespToXapp, 2},
315 rparams1 := &teststube2ap.E2StubSubsReqParams{}
317 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
318 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
319 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
320 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
323 rparams2 := &teststube2ap.E2StubSubsReqParams{}
325 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
326 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
328 resp, _ := xapp.Subscription.QuerySubscriptions()
329 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
330 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
331 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
334 waiter := rtmgrHttp.AllocNextEvent(false)
335 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
338 xappConn1.RecvSubsDelResp(t, deltrans1)
341 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
342 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
343 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
344 xappConn2.RecvSubsDelResp(t, deltrans2)
345 //Wait that subs is cleaned
346 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
348 xappConn1.TestMsgChanEmpty(t)
349 xappConn2.TestMsgChanEmpty(t)
350 e2termConn1.TestMsgChanEmpty(t)
351 mainCtrl.wait_registry_empty(t, 10)
353 mainCtrl.VerifyCounterValues(t)
356 //-----------------------------------------------------------------------------
358 //-----------------------------------------------------------------------------
359 // TestSubReqAndSubDelOk
362 // +-------+ +---------+ +---------+
363 // | xapp | | submgr | | e2term |
364 // +-------+ +---------+ +---------+
367 // |------------->| |
370 // | |------------->|
373 // | |<-------------|
376 // |<-------------| |
380 // |------------->| |
383 // | |------------->|
386 // | |<-------------|
389 // |<-------------| |
391 //-----------------------------------------------------------------------------
392 func TestSubReqAndSubDelOk(t *testing.T) {
393 CaseBegin("TestSubReqAndSubDelOk")
395 // Init counter check
396 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
397 Counter{cSubReqFromXapp, 1},
398 Counter{cSubReqToE2, 1},
399 Counter{cSubRespFromE2, 1},
400 Counter{cSubRespToXapp, 1},
401 Counter{cSubDelReqFromXapp, 1},
402 Counter{cSubDelReqToE2, 1},
403 Counter{cSubDelRespFromE2, 1},
404 Counter{cSubDelRespToXapp, 1},
407 cretrans := xappConn1.SendSubsReq(t, nil, nil)
408 crereq, cremsg := e2termConn1.RecvSubsReq(t)
409 e2termConn1.SendSubsResp(t, crereq, cremsg)
410 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
412 resp, _ := xapp.Subscription.QuerySubscriptions()
413 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
414 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
415 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
417 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
418 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
420 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
421 xappConn1.RecvSubsDelResp(t, deltrans)
423 //Wait that subs is cleaned
424 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
426 xappConn1.TestMsgChanEmpty(t)
427 xappConn2.TestMsgChanEmpty(t)
428 e2termConn1.TestMsgChanEmpty(t)
429 mainCtrl.wait_registry_empty(t, 10)
431 mainCtrl.VerifyCounterValues(t)
434 //-----------------------------------------------------------------------------
435 // TestSubReqRetransmission
438 // +-------+ +---------+ +---------+
439 // | xapp | | submgr | | e2term |
440 // +-------+ +---------+ +---------+
443 // |------------->| |
446 // | |------------->|
450 // |------------->| |
453 // | |<-------------|
456 // |<-------------| |
461 //-----------------------------------------------------------------------------
462 func TestSubReqRetransmission(t *testing.T) {
463 CaseBegin("TestSubReqRetransmission")
466 cretrans := xappConn1.SendSubsReq(t, nil, nil)
467 crereq, cremsg := e2termConn1.RecvSubsReq(t)
469 seqBef := mainCtrl.get_msgcounter(t)
470 xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq
471 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
473 // hack as there is no real way to see has message be handled.
474 // Previuos counter check just tells that is has been received by submgr
475 // --> artificial delay
476 <-time.After(1 * time.Second)
477 e2termConn1.SendSubsResp(t, crereq, cremsg)
478 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
481 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
482 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
483 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
484 xappConn1.RecvSubsDelResp(t, deltrans)
486 //Wait that subs is cleaned
487 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
489 xappConn1.TestMsgChanEmpty(t)
490 xappConn2.TestMsgChanEmpty(t)
491 e2termConn1.TestMsgChanEmpty(t)
492 mainCtrl.wait_registry_empty(t, 10)
495 //-----------------------------------------------------------------------------
496 // TestSubDelReqRetransmission
499 // +-------+ +---------+ +---------+
500 // | xapp | | submgr | | e2term |
501 // +-------+ +---------+ +---------+
507 // |------------->| |
510 // | |------------->|
515 // |------------->| |
518 // | |<-------------|
521 // |<-------------| |
523 //-----------------------------------------------------------------------------
524 func TestSubDelReqRetransmission(t *testing.T) {
525 CaseBegin("TestSubDelReqRetransmission")
528 cretrans := xappConn1.SendSubsReq(t, nil, nil)
529 crereq, cremsg := e2termConn1.RecvSubsReq(t)
530 e2termConn1.SendSubsResp(t, crereq, cremsg)
531 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
534 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
535 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
537 seqBef := mainCtrl.get_msgcounter(t)
538 xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq
539 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
541 // hack as there is no real way to see has message be handled.
542 // Previuos counter check just tells that is has been received by submgr
543 // --> artificial delay
544 <-time.After(1 * time.Second)
546 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
547 xappConn1.RecvSubsDelResp(t, deltrans)
549 //Wait that subs is cleaned
550 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
552 xappConn1.TestMsgChanEmpty(t)
553 xappConn2.TestMsgChanEmpty(t)
554 e2termConn1.TestMsgChanEmpty(t)
555 mainCtrl.wait_registry_empty(t, 10)
558 //-----------------------------------------------------------------------------
559 // TestSubDelReqCollision
562 // +-------+ +---------+ +---------+
563 // | xapp | | submgr | | e2term |
564 // +-------+ +---------+ +---------+
570 // |------------->| |
573 // | |------------->|
578 // |------------->| |
580 // | | SubDelResp 1 |
581 // | |<-------------|
583 // | SubDelResp 1 | |
584 // |<-------------| |
586 // | SubDelResp 2 | |
587 // |<-------------| |
589 //-----------------------------------------------------------------------------
591 func TestSubDelReqCollision(t *testing.T) {
592 CaseBegin("TestSubDelReqCollision")
595 cretrans := xappConn1.SendSubsReq(t, nil, nil)
596 crereq, cremsg := e2termConn1.RecvSubsReq(t)
597 e2termConn1.SendSubsResp(t, crereq, cremsg)
598 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
601 xappConn1.SendSubsDelReq(t, nil, e2SubsId)
602 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
604 // Subs Delete colliding
605 seqBef := mainCtrl.get_msgcounter(t)
606 deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
607 xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq
608 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
610 // hack as there is no real way to see has message be handled.
611 // Previuos counter check just tells that is has been received by submgr
612 // --> artificial delay
613 <-time.After(1 * time.Second)
615 // Del resp for first and second
616 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
618 // don't care in which order responses are received
619 xappConn1.RecvSubsDelResp(t, nil)
620 xappConn1.RecvSubsDelResp(t, nil)
622 //Wait that subs is cleaned
623 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
625 xappConn1.TestMsgChanEmpty(t)
626 xappConn2.TestMsgChanEmpty(t)
627 e2termConn1.TestMsgChanEmpty(t)
628 mainCtrl.wait_registry_empty(t, 10)
631 //-----------------------------------------------------------------------------
632 // TestSubReqAndSubDelOkTwoParallel
635 // +-------+ +-------+ +---------+ +---------+
636 // | xapp | | xapp | | submgr | | e2term |
637 // +-------+ +-------+ +---------+ +---------+
642 // | |------------->| |
645 // | | |------------->|
648 // |------------------------>| |
651 // | | |------------->|
654 // | | |<-------------|
656 // | |<-------------| |
659 // | | |<-------------|
661 // |<------------------------| |
663 // | | [SUBS 1 DELETE] |
665 // | | [SUBS 2 DELETE] |
668 //-----------------------------------------------------------------------------
670 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
671 CaseBegin("TestSubReqAndSubDelOkTwoParallel")
674 rparams1 := &teststube2ap.E2StubSubsReqParams{}
676 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
677 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
680 rparams2 := &teststube2ap.E2StubSubsReqParams{}
683 rparams2.Req.EventTriggerDefinition.Data.Length = 1
684 rparams2.Req.EventTriggerDefinition.Data.Data = make([]uint8, rparams2.Req.EventTriggerDefinition.Data.Length)
685 rparams2.Req.EventTriggerDefinition.Data.Data[0] = 2
687 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
688 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
691 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
692 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
695 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
696 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
699 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
700 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
701 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
702 xappConn1.RecvSubsDelResp(t, deltrans1)
703 //Wait that subs is cleaned
704 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
707 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
708 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
709 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
710 xappConn2.RecvSubsDelResp(t, deltrans2)
711 //Wait that subs is cleaned
712 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
714 xappConn1.TestMsgChanEmpty(t)
715 xappConn2.TestMsgChanEmpty(t)
716 e2termConn1.TestMsgChanEmpty(t)
717 mainCtrl.wait_registry_empty(t, 10)
720 //-----------------------------------------------------------------------------
721 // TestSameSubsDiffRan
722 // Same subscription to different RANs
725 // +-------+ +---------+ +---------+
726 // | xapp | | submgr | | e2term |
727 // +-------+ +---------+ +---------+
732 // |------------->| |
735 // | |------------->|
738 // | |<-------------|
741 // |<-------------| |
744 // |------------->| |
747 // | |------------->|
750 // | |<-------------|
753 // |<-------------| |
755 // | [SUBS r1 DELETE] |
757 // | [SUBS r2 DELETE] |
760 //-----------------------------------------------------------------------------
761 func TestSameSubsDiffRan(t *testing.T) {
762 CaseBegin("TestSameSubsDiffRan")
765 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
766 xappConn1.SendSubsReq(t, nil, cretrans1)
767 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
768 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
769 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
772 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
773 xappConn1.SendSubsReq(t, nil, cretrans2)
774 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
775 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
776 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
779 deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
780 xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
781 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
782 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
783 xappConn1.RecvSubsDelResp(t, deltrans1)
784 //Wait that subs is cleaned
785 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
788 deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
789 xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
790 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
791 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
792 xappConn1.RecvSubsDelResp(t, deltrans2)
793 //Wait that subs is cleaned
794 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
796 xappConn1.TestMsgChanEmpty(t)
797 xappConn2.TestMsgChanEmpty(t)
798 e2termConn1.TestMsgChanEmpty(t)
799 mainCtrl.wait_registry_empty(t, 10)
802 //-----------------------------------------------------------------------------
803 // TestSubReqRetryInSubmgr
806 // +-------+ +---------+ +---------+
807 // | xapp | | submgr | | e2term |
808 // +-------+ +---------+ +---------+
811 // |------------->| |
814 // | |------------->|
818 // | |------------->|
821 // | |<-------------|
824 // |<-------------| |
829 //-----------------------------------------------------------------------------
831 func TestSubReqRetryInSubmgr(t *testing.T) {
832 CaseBegin("TestSubReqRetryInSubmgr start")
834 // Init counter check
835 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
836 Counter{cSubReqFromXapp, 1},
837 Counter{cSubReqToE2, 1},
838 Counter{cSubReReqToE2, 1},
839 Counter{cSubRespFromE2, 1},
840 Counter{cSubRespToXapp, 1},
841 Counter{cSubDelReqFromXapp, 1},
842 Counter{cSubDelReqToE2, 1},
843 Counter{cSubDelRespFromE2, 1},
844 Counter{cSubDelRespToXapp, 1},
847 // Xapp: Send SubsReq
848 cretrans := xappConn1.SendSubsReq(t, nil, nil)
850 // E2t: Receive 1st SubsReq
851 e2termConn1.RecvSubsReq(t)
853 // E2t: Receive 2nd SubsReq and send SubsResp
854 crereq, cremsg := e2termConn1.RecvSubsReq(t)
855 e2termConn1.SendSubsResp(t, crereq, cremsg)
857 // Xapp: Receive SubsResp
858 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
860 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
861 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
862 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
863 xappConn1.RecvSubsDelResp(t, deltrans)
865 // Wait that subs is cleaned
866 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
868 xappConn1.TestMsgChanEmpty(t)
869 xappConn2.TestMsgChanEmpty(t)
870 e2termConn1.TestMsgChanEmpty(t)
871 mainCtrl.wait_registry_empty(t, 10)
873 mainCtrl.VerifyCounterValues(t)
876 //-----------------------------------------------------------------------------
877 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
880 // +-------+ +---------+ +---------+
881 // | xapp | | submgr | | e2term |
882 // +-------+ +---------+ +---------+
885 // |------------->| |
888 // | |------------->|
892 // | |------------->|
895 // | |------------->|
898 // | |<-------------|
901 //-----------------------------------------------------------------------------
902 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
903 CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
905 // Init counter check
906 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
907 Counter{cSubReqFromXapp, 1},
908 Counter{cSubReqToE2, 1},
909 Counter{cSubReReqToE2, 1},
910 Counter{cSubReqTimerExpiry, 2},
911 Counter{cSubDelReqToE2, 1},
912 Counter{cSubDelRespFromE2, 1},
915 // Xapp: Send SubsReq
916 xappConn1.SendSubsReq(t, nil, nil)
918 // E2t: Receive 1st SubsReq
919 e2termConn1.RecvSubsReq(t)
921 // E2t: Receive 2nd SubsReq
922 e2termConn1.RecvSubsReq(t)
924 // E2t: Send receive SubsDelReq and send SubsResp
925 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
926 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
928 // Wait that subs is cleaned
929 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 10)
931 xappConn1.TestMsgChanEmpty(t)
932 xappConn2.TestMsgChanEmpty(t)
933 e2termConn1.TestMsgChanEmpty(t)
934 mainCtrl.wait_registry_empty(t, 10)
936 mainCtrl.VerifyCounterValues(t)
939 //-----------------------------------------------------------------------------
940 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
943 // +-------+ +---------+ +---------+
944 // | xapp | | submgr | | e2term |
945 // +-------+ +---------+ +---------+
948 // |------------->| |
951 // | |------------->|
955 // | |------------->|
958 // | |------------->|
962 // | |------------->|
966 //-----------------------------------------------------------------------------
968 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
969 CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
971 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
972 Counter{cSubReqFromXapp, 1},
973 Counter{cSubReqToE2, 1},
974 Counter{cSubReReqToE2, 1},
975 Counter{cSubReqTimerExpiry, 2},
976 Counter{cSubDelReqToE2, 1},
977 Counter{cSubDelReReqToE2, 1},
978 Counter{cSubDelReqTimerExpiry, 2},
981 // Xapp: Send SubsReq
982 xappConn1.SendSubsReq(t, nil, nil)
984 // E2t: Receive 1st SubsReq
985 e2termConn1.RecvSubsReq(t)
987 // E2t: Receive 2nd SubsReq
988 e2termConn1.RecvSubsReq(t)
990 // E2t: Receive 1st SubsDelReq
991 e2termConn1.RecvSubsDelReq(t)
993 // E2t: Receive 2nd SubsDelReq
994 delreq, _ := e2termConn1.RecvSubsDelReq(t)
996 // Wait that subs is cleaned
997 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 15)
999 xappConn1.TestMsgChanEmpty(t)
1000 xappConn2.TestMsgChanEmpty(t)
1001 e2termConn1.TestMsgChanEmpty(t)
1002 mainCtrl.wait_registry_empty(t, 10)
1004 mainCtrl.VerifyCounterValues(t)
1007 //-----------------------------------------------------------------------------
1008 // TestSubReqSubFailRespInSubmgr
1011 // +-------+ +---------+ +---------+
1012 // | xapp | | submgr | | e2term |
1013 // +-------+ +---------+ +---------+
1016 // |------------->| |
1019 // | |------------->|
1022 // | |<-------------|
1025 // | |------------->|
1028 // | |<-------------|
1031 // |<-------------| |
1034 //-----------------------------------------------------------------------------
1036 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1037 CaseBegin("TestSubReqSubFailRespInSubmgr start")
1039 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1040 Counter{cSubReqFromXapp, 1},
1041 Counter{cSubReqToE2, 1},
1042 Counter{cSubFailFromE2, 1},
1043 Counter{cSubFailToXapp, 1},
1046 // Xapp: Send SubsReq
1047 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1049 // E2t: Receive SubsReq and send SubsFail (first)
1050 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1051 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1052 fparams1.Set(crereq1)
1053 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1055 // E2t: Receive SubsDelReq and send SubsDelResp (internal first)
1056 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1057 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1059 // Xapp: Receive SubsFail
1060 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
1062 // Wait that subs is cleaned
1063 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1065 xappConn1.TestMsgChanEmpty(t)
1066 xappConn2.TestMsgChanEmpty(t)
1067 e2termConn1.TestMsgChanEmpty(t)
1068 mainCtrl.wait_registry_empty(t, 10)
1070 mainCtrl.VerifyCounterValues(t)
1073 //-----------------------------------------------------------------------------
1074 // TestSubDelReqRetryInSubmgr
1077 // +-------+ +---------+ +---------+
1078 // | xapp | | submgr | | e2term |
1079 // +-------+ +---------+ +---------+
1081 // | [SUBS CREATE] |
1085 // |------------->| |
1088 // | |------------->|
1091 // | |------------->|
1094 // | |<-------------|
1097 // |<-------------| |
1099 //-----------------------------------------------------------------------------
1101 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1103 CaseBegin("TestSubDelReqRetryInSubmgr start")
1106 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1107 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1108 e2termConn1.SendSubsResp(t, crereq, cremsg)
1109 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1112 // Xapp: Send SubsDelReq
1113 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1115 // E2t: Receive 1st SubsDelReq
1116 e2termConn1.RecvSubsDelReq(t)
1118 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1119 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1120 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1122 // Xapp: Receive SubsDelResp
1123 xappConn1.RecvSubsDelResp(t, deltrans)
1125 // Wait that subs is cleaned
1126 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1128 xappConn1.TestMsgChanEmpty(t)
1129 xappConn2.TestMsgChanEmpty(t)
1130 e2termConn1.TestMsgChanEmpty(t)
1131 mainCtrl.wait_registry_empty(t, 10)
1134 //-----------------------------------------------------------------------------
1135 // TestSubDelReqTwoRetriesNoRespInSubmgr
1138 // +-------+ +---------+ +---------+
1139 // | xapp | | submgr | | e2term |
1140 // +-------+ +---------+ +---------+
1142 // | [SUBS CREATE] |
1146 // |------------->| |
1149 // | |------------->|
1152 // | |------------->|
1156 // |<-------------| |
1158 //-----------------------------------------------------------------------------
1160 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1162 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
1165 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1166 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1167 e2termConn1.SendSubsResp(t, crereq, cremsg)
1168 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1171 // Xapp: Send SubsDelReq
1172 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1174 // E2t: Receive 1st SubsDelReq
1175 e2termConn1.RecvSubsDelReq(t)
1177 // E2t: Receive 2nd SubsDelReq
1178 e2termConn1.RecvSubsDelReq(t)
1180 // Xapp: Receive SubsDelResp
1181 xappConn1.RecvSubsDelResp(t, deltrans)
1183 // Wait that subs is cleaned
1184 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1186 xappConn1.TestMsgChanEmpty(t)
1187 xappConn2.TestMsgChanEmpty(t)
1188 e2termConn1.TestMsgChanEmpty(t)
1189 mainCtrl.wait_registry_empty(t, 10)
1192 //-----------------------------------------------------------------------------
1193 // TestSubDelReqSubDelFailRespInSubmgr
1196 // +-------+ +---------+ +---------+
1197 // | xapp | | submgr | | e2term |
1198 // +-------+ +---------+ +---------+
1200 // | [SUBS CREATE] |
1204 // |------------->| |
1207 // | |------------->|
1210 // | |<-------------|
1213 // |<-------------| |
1216 //-----------------------------------------------------------------------------
1218 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1219 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1221 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1222 Counter{cSubReqFromXapp, 1},
1223 Counter{cSubReqToE2, 1},
1224 Counter{cSubRespFromE2, 1},
1225 Counter{cSubRespToXapp, 1},
1226 Counter{cSubDelReqFromXapp, 1},
1227 Counter{cSubDelReqToE2, 1},
1228 Counter{cSubDelFailFromE2, 1},
1229 Counter{cSubDelRespToXapp, 1},
1233 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1234 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1235 e2termConn1.SendSubsResp(t, crereq, cremsg)
1236 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1238 // Xapp: Send SubsDelReq
1239 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1241 // E2t: Send receive SubsDelReq and send SubsDelFail
1242 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1243 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1245 // Xapp: Receive SubsDelResp
1246 xappConn1.RecvSubsDelResp(t, deltrans)
1248 // Wait that subs is cleaned
1249 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1251 xappConn1.TestMsgChanEmpty(t)
1252 xappConn2.TestMsgChanEmpty(t)
1253 e2termConn1.TestMsgChanEmpty(t)
1254 mainCtrl.wait_registry_empty(t, 10)
1256 mainCtrl.VerifyCounterValues(t)
1259 //-----------------------------------------------------------------------------
1260 // TestSubReqAndSubDelOkSameAction
1263 // +-------+ +-------+ +---------+ +---------+
1264 // | xapp2 | | xapp1 | | submgr | | e2term |
1265 // +-------+ +-------+ +---------+ +---------+
1270 // | |------------->| |
1273 // | | |------------->|
1275 // | | |<-------------|
1277 // | |<-------------| |
1280 // |--------------------------->| |
1283 // |<---------------------------| |
1285 // | | SubDelReq 1 | |
1286 // | |------------->| |
1288 // | | SubDelResp 1 | |
1289 // | |<-------------| |
1291 // | SubDelReq 2 | |
1292 // |--------------------------->| |
1294 // | | | SubDelReq 2 |
1295 // | | |------------->|
1297 // | | | SubDelReq 2 |
1298 // | | |------------->|
1300 // | SubDelResp 2 | |
1301 // |<---------------------------| |
1303 //-----------------------------------------------------------------------------
1304 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
1305 CaseBegin("TestSubReqAndSubDelOkSameAction")
1307 // Init counter check
1308 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1309 Counter{cSubReqFromXapp, 2},
1310 Counter{cSubReqToE2, 1},
1311 Counter{cSubRespFromE2, 1},
1312 Counter{cSubRespToXapp, 2},
1313 Counter{cMergedSubscriptions, 1},
1314 Counter{cUnmergedSubscriptions, 1},
1315 Counter{cSubDelReqFromXapp, 2},
1316 Counter{cSubDelReqToE2, 1},
1317 Counter{cSubDelRespFromE2, 1},
1318 Counter{cSubDelRespToXapp, 2},
1322 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1324 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1325 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1326 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1327 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1330 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1332 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1333 //crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1334 //e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1335 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1337 resp, _ := xapp.Subscription.QuerySubscriptions()
1338 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1339 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1340 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
1343 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1344 //e2termConn1.RecvSubsDelReq(t)
1345 //e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1346 xappConn1.RecvSubsDelResp(t, deltrans1)
1347 //Wait that subs is cleaned
1348 //mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1351 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1352 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1353 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1354 xappConn2.RecvSubsDelResp(t, deltrans2)
1355 //Wait that subs is cleaned
1356 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1358 xappConn1.TestMsgChanEmpty(t)
1359 xappConn2.TestMsgChanEmpty(t)
1360 e2termConn1.TestMsgChanEmpty(t)
1361 mainCtrl.wait_registry_empty(t, 10)
1363 mainCtrl.VerifyCounterValues(t)
1366 //-----------------------------------------------------------------------------
1367 // TestSubReqAndSubDelOkSameActionParallel
1370 // +-------+ +-------+ +---------+ +---------+
1371 // | xapp2 | | xapp1 | | submgr | | e2term |
1372 // +-------+ +-------+ +---------+ +---------+
1377 // | |------------->| |
1380 // | | |------------->|
1382 // |--------------------------->| |
1384 // | | |<-------------|
1386 // | |<-------------| |
1389 // |<---------------------------| |
1391 // | | SubDelReq 1 | |
1392 // | |------------->| |
1394 // | | SubDelResp 1 | |
1395 // | |<-------------| |
1397 // | SubDelReq 2 | |
1398 // |--------------------------->| |
1400 // | | | SubDelReq 2 |
1401 // | | |------------->|
1403 // | | | SubDelReq 2 |
1404 // | | |------------->|
1406 // | SubDelResp 2 | |
1407 // |<---------------------------| |
1409 //-----------------------------------------------------------------------------
1410 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1411 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1414 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1416 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1417 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1420 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1422 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1425 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1426 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1429 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1432 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1433 xappConn1.RecvSubsDelResp(t, deltrans1)
1436 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1437 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1438 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1439 xappConn2.RecvSubsDelResp(t, deltrans2)
1441 //Wait that subs is cleaned
1442 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1444 xappConn1.TestMsgChanEmpty(t)
1445 xappConn2.TestMsgChanEmpty(t)
1446 e2termConn1.TestMsgChanEmpty(t)
1447 mainCtrl.wait_registry_empty(t, 10)
1450 //-----------------------------------------------------------------------------
1451 // TestSubReqAndSubDelNokSameActionParallel
1454 // +-------+ +-------+ +---------+ +---------+
1455 // | xapp2 | | xapp1 | | submgr | | e2term |
1456 // +-------+ +-------+ +---------+ +---------+
1461 // | |------------->| |
1464 // | | |------------->|
1466 // |--------------------------->| |
1468 // | | |<-------------|
1470 // | | | SubDelReq |
1471 // | | |------------->|
1472 // | | | SubDelResp |
1473 // | | |<-------------|
1476 // | |<-------------| |
1479 // |<---------------------------| |
1481 //-----------------------------------------------------------------------------
1482 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1483 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1486 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1488 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1490 // E2t: Receive SubsReq (first)
1491 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1494 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1496 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1497 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1498 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1500 // E2t: send SubsFail (first)
1501 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1502 fparams1.Set(crereq1)
1503 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1505 // E2t: internal delete
1506 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1507 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1510 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1512 xappConn2.RecvSubsFail(t, cretrans2)
1514 //Wait that subs is cleaned
1515 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1517 xappConn1.TestMsgChanEmpty(t)
1518 xappConn2.TestMsgChanEmpty(t)
1519 e2termConn1.TestMsgChanEmpty(t)
1520 mainCtrl.wait_registry_empty(t, 10)
1523 //-----------------------------------------------------------------------------
1524 // TestSubReqAndSubDelNoAnswerSameActionParallel
1527 // +-------+ +-------+ +---------+ +---------+
1528 // | xapp2 | | xapp1 | | submgr | | e2term |
1529 // +-------+ +-------+ +---------+ +---------+
1534 // | |------------->| |
1537 // | | |------------->|
1539 // |--------------------------->| |
1542 // | | |------------->|
1545 // | | | SubDelReq |
1546 // | | |------------->|
1548 // | | | SubDelResp |
1549 // | | |<-------------|
1551 //-----------------------------------------------------------------------------
1552 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1553 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1556 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1558 xappConn1.SendSubsReq(t, rparams1, nil)
1560 crereq1, _ := e2termConn1.RecvSubsReq(t)
1563 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1565 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1566 xappConn2.SendSubsReq(t, rparams2, nil)
1567 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1569 //Req1 (retransmitted)
1570 e2termConn1.RecvSubsReq(t)
1572 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1573 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1575 //Wait that subs is cleaned
1576 mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10)
1578 xappConn1.TestMsgChanEmpty(t)
1579 xappConn2.TestMsgChanEmpty(t)
1580 e2termConn1.TestMsgChanEmpty(t)
1581 mainCtrl.wait_registry_empty(t, 15)
1584 //----------------------------- Policy cases ---------------------------------
1585 //-----------------------------------------------------------------------------
1586 // TestSubReqPolicyAndSubDelOk
1589 // +-------+ +---------+ +---------+
1590 // | xapp | | submgr | | e2term |
1591 // +-------+ +---------+ +---------+
1594 // |------------->| |
1597 // | |------------->|
1600 // | |<-------------|
1603 // |<-------------| |
1607 // |------------->| |
1610 // | |------------->|
1613 // | |<-------------|
1616 // |<-------------| |
1618 //-----------------------------------------------------------------------------
1619 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
1620 CaseBegin("TestSubReqAndSubDelOk")
1622 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1624 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1625 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1627 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1628 e2termConn1.SendSubsResp(t, crereq, cremsg)
1629 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1630 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1631 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1633 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1634 xappConn1.RecvSubsDelResp(t, deltrans)
1636 //Wait that subs is cleaned
1637 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1639 xappConn1.TestMsgChanEmpty(t)
1640 xappConn2.TestMsgChanEmpty(t)
1641 e2termConn1.TestMsgChanEmpty(t)
1642 mainCtrl.wait_registry_empty(t, 10)
1645 //-----------------------------------------------------------------------------
1646 // TestSubReqPolicyChangeAndSubDelOk
1649 // +-------+ +---------+ +---------+
1650 // | xapp | | submgr | | e2term |
1651 // +-------+ +---------+ +---------+
1654 // |------------->| |
1657 // | |------------->|
1660 // | |<-------------|
1663 // |<-------------| |
1666 // |------------->| |
1669 // | |------------->|
1672 // | |<-------------|
1675 // |<-------------| |
1678 // |------------->| |
1681 // | |------------->|
1684 // | |<-------------|
1687 // |<-------------| |
1689 //-----------------------------------------------------------------------------
1691 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
1692 CaseBegin("TestSubReqAndSubDelOk")
1694 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1696 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1697 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1699 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1700 e2termConn1.SendSubsResp(t, crereq, cremsg)
1701 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1704 rparams1.Req.RequestId.InstanceId = e2SubsId
1705 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
1706 xappConn1.SendSubsReq(t, rparams1, cretrans)
1708 crereq, cremsg = e2termConn1.RecvSubsReq(t)
1709 e2termConn1.SendSubsResp(t, crereq, cremsg)
1710 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1711 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1712 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1714 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1715 xappConn1.RecvSubsDelResp(t, deltrans)
1717 //Wait that subs is cleaned
1718 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1720 xappConn1.TestMsgChanEmpty(t)
1721 xappConn2.TestMsgChanEmpty(t)
1722 e2termConn1.TestMsgChanEmpty(t)
1723 mainCtrl.wait_registry_empty(t, 10)
1726 //-----------------------------------------------------------------------------
1727 // TestSubReqAndSubDelOkTwoE2termParallel
1730 // +-------+ +---------+ +---------+ +---------+
1731 // | xapp | | submgr | | e2term1 | | e2term2 |
1732 // +-------+ +---------+ +---------+ +---------+
1737 // |------------->| | |
1740 // | |------------->| |
1743 // |------------->| | |
1746 // | |---------------------------->|
1749 // | |<-------------| |
1751 // |<-------------| | |
1753 // | |<----------------------------|
1755 // |<-------------| | |
1757 // | [SUBS 1 DELETE] | |
1759 // | [SUBS 2 DELETE] | |
1762 //-----------------------------------------------------------------------------
1763 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
1764 CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
1767 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1768 xappConn1.SendSubsReq(t, nil, cretrans1)
1769 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1771 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
1772 xappConn1.SendSubsReq(t, nil, cretrans2)
1773 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
1776 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1777 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1780 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
1781 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1784 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1785 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1786 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1787 xappConn1.RecvSubsDelResp(t, deltrans1)
1788 //Wait that subs is cleaned
1789 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1792 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
1793 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
1794 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
1795 xappConn1.RecvSubsDelResp(t, deltrans2)
1796 //Wait that subs is cleaned
1797 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1799 xappConn1.TestMsgChanEmpty(t)
1800 xappConn2.TestMsgChanEmpty(t)
1801 e2termConn1.TestMsgChanEmpty(t)
1802 e2termConn2.TestMsgChanEmpty(t)
1803 mainCtrl.wait_registry_empty(t, 10)
1806 //-----------------------------------------------------------------------------
1807 // TestSubReqInsertAndSubDelOk
1810 // +-------+ +---------+ +---------+
1811 // | xapp | | submgr | | e2term |
1812 // +-------+ +---------+ +---------+
1815 // |------------->| |
1818 // | |------------->|
1821 // | |<-------------|
1824 // |<-------------| |
1828 // |------------->| |
1831 // | |------------->|
1834 // | |<-------------|
1837 // |<-------------| |
1839 //-----------------------------------------------------------------------------
1840 func TestSubReqInsertAndSubDelOk(t *testing.T) {
1841 CaseBegin("TestInsertSubReqAndSubDelOk")
1843 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1845 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeInsert
1846 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1848 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1849 e2termConn1.SendSubsResp(t, crereq, cremsg)
1850 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1851 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1852 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1854 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1855 xappConn1.RecvSubsDelResp(t, deltrans)
1857 //Wait that subs is cleaned
1858 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1860 xappConn1.TestMsgChanEmpty(t)
1861 xappConn2.TestMsgChanEmpty(t)
1862 e2termConn1.TestMsgChanEmpty(t)
1863 mainCtrl.wait_registry_empty(t, 10)
1866 //-----------------------------------------------------------------------------
1867 // TestSubReqRetransmissionWithSameSubIdDiffXid
1869 // This case simulates case where xApp restarts and starts sending same
1870 // subscription requests which have already subscribed successfully
1873 // +-------+ +---------+ +---------+
1874 // | xapp | | submgr | | e2term |
1875 // +-------+ +---------+ +---------+
1878 // |------------->| |
1881 // | |------------->|
1884 // | |<-------------|
1887 // |<-------------| |
1889 // | xApp restart | |
1892 // | (retrans with same xApp generated subid but diff xid)
1893 // |------------->| |
1896 // |<-------------| |
1898 // | [SUBS DELETE] |
1901 //-----------------------------------------------------------------------------
1902 func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) {
1903 CaseBegin("TestSubReqRetransmissionWithSameSubIdDiffXid")
1906 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1907 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1908 e2termConn1.SendSubsResp(t, crereq, cremsg)
1909 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1911 // xApp restart here
1912 // --> artificial delay
1913 <-time.After(1 * time.Second)
1916 cretrans = xappConn1.SendSubsReq(t, nil, nil) //Retransmitted SubReq
1917 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1920 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1921 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1922 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1923 xappConn1.RecvSubsDelResp(t, deltrans)
1925 //Wait that subs is cleaned
1926 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1928 xappConn1.TestMsgChanEmpty(t)
1929 xappConn2.TestMsgChanEmpty(t)
1930 e2termConn1.TestMsgChanEmpty(t)
1931 mainCtrl.wait_registry_empty(t, 10)
1934 //-----------------------------------------------------------------------------
1935 // TestSubReqNokAndSubDelOkWithRestartInMiddle
1938 // +-------+ +---------+ +---------+
1939 // | xapp | | submgr | | e2term |
1940 // +-------+ +---------+ +---------+
1943 // |------------->| |
1946 // | |------------->|
1951 // | Submgr restart |
1955 // | |------------->|
1958 // | |<-------------|
1961 //-----------------------------------------------------------------------------
1963 func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
1964 CaseBegin("TestSubReqNokAndSubDelOkWithRestartInMiddle")
1966 // Remove possible existing subscrition
1967 mainCtrl.removeExistingSubscriptions(t)
1969 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
1970 xappConn1.SendSubsReq(t, nil, nil)
1971 e2termConn1.RecvSubsReq(t)
1972 mainCtrl.SetResetTestFlag(t, false)
1974 resp, _ := xapp.Subscription.QuerySubscriptions()
1975 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1976 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
1977 e2SubsId := uint32(resp[0].SubscriptionID)
1978 t.Logf("e2SubsId = %v", e2SubsId)
1980 mainCtrl.SimulateRestart(t)
1981 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
1983 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1984 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1986 // Wait that subs is cleaned
1987 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1989 xappConn1.TestMsgChanEmpty(t)
1990 xappConn2.TestMsgChanEmpty(t)
1991 e2termConn1.TestMsgChanEmpty(t)
1992 mainCtrl.wait_registry_empty(t, 10)
1995 //-----------------------------------------------------------------------------
1996 // TestSubReqAndSubDelOkWithRestartInMiddle
1999 // +-------+ +---------+ +---------+
2000 // | xapp | | submgr | | e2term |
2001 // +-------+ +---------+ +---------+
2004 // |------------->| |
2007 // | |------------->|
2010 // | |<-------------|
2013 // |<-------------| |
2016 // | Submgr restart |
2019 // |------------->| |
2022 // | |------------->|
2025 // | |<-------------|
2028 // |<-------------| |
2030 //-----------------------------------------------------------------------------
2032 func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
2033 CaseBegin("TestSubReqAndSubDelOkWithRestartInMiddle")
2035 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2036 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2037 e2termConn1.SendSubsResp(t, crereq, cremsg)
2038 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2040 // Check subscription
2041 resp, _ := xapp.Subscription.QuerySubscriptions()
2042 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2043 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2044 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2046 mainCtrl.SimulateRestart(t)
2047 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2049 // Check that subscription is restored correctly after restart
2050 resp, _ = xapp.Subscription.QuerySubscriptions()
2051 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2052 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2053 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2055 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2056 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2057 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2058 xappConn1.RecvSubsDelResp(t, deltrans)
2060 //Wait that subs is cleaned
2061 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2063 xappConn1.TestMsgChanEmpty(t)
2064 xappConn2.TestMsgChanEmpty(t)
2065 e2termConn1.TestMsgChanEmpty(t)
2066 mainCtrl.wait_registry_empty(t, 10)
2069 //-----------------------------------------------------------------------------
2070 // TestSubReqAndSubDelOkSameActionWithRestartsInMiddle
2073 // +-------+ +-------+ +---------+ +---------+
2074 // | xapp2 | | xapp1 | | submgr | | e2term |
2075 // +-------+ +-------+ +---------+ +---------+
2080 // | |------------->| |
2083 // | | |------------->|
2085 // | | |<-------------|
2087 // | |<-------------| |
2090 // | submgr restart |
2095 // |--------------------------->| |
2098 // |<---------------------------| |
2100 // | | SubDelReq 1 | |
2101 // | |------------->| |
2103 // | | SubDelResp 1 | |
2104 // | |<-------------| |
2108 // | submgr restart |
2111 // | SubDelReq 2 | |
2112 // |--------------------------->| |
2114 // | | | SubDelReq 2 |
2115 // | | |------------->|
2117 // | | | SubDelReq 2 |
2118 // | | |------------->|
2120 // | SubDelResp 2 | |
2121 // |<---------------------------| |
2123 //-----------------------------------------------------------------------------
2125 func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
2126 CaseBegin("TestSubReqAndSubDelOkSameActionWithRestartsInMiddle")
2129 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2131 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2132 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2133 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2134 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2137 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2139 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2140 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
2142 // Check subscription
2143 resp, _ := xapp.Subscription.QuerySubscriptions() ////////////////////////////////
2144 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2145 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2146 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2148 mainCtrl.SimulateRestart(t)
2149 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2151 // Check that subscription is restored correctly after restart
2152 resp, _ = xapp.Subscription.QuerySubscriptions()
2153 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2154 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2155 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2158 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2159 xapp.Logger.Debug("xappConn1.RecvSubsDelResp")
2160 xappConn1.RecvSubsDelResp(t, deltrans1)
2161 xapp.Logger.Debug("xappConn1.RecvSubsDelResp received")
2163 mainCtrl.SimulateRestart(t)
2164 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2167 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
2168 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2170 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2171 xappConn2.RecvSubsDelResp(t, deltrans2)
2173 //Wait that subs is cleaned
2174 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2176 xappConn1.TestMsgChanEmpty(t)
2177 xappConn2.TestMsgChanEmpty(t)
2178 e2termConn1.TestMsgChanEmpty(t)
2179 mainCtrl.wait_registry_empty(t, 10)
2182 //*****************************************************************************
2183 // REST interface test cases
2184 //*****************************************************************************
2186 //-----------------------------------------------------------------------------
2187 // Test debug GET and POST requests
2190 // +-------+ +---------+
2191 // | user | | submgr |
2192 // +-------+ +---------+
2199 func TestGetSubscriptions(t *testing.T) {
2201 mainCtrl.sendGetRequest(t, "localhost:8088", "/ric/v1/subscriptions")
2204 func TestGetSymptomData(t *testing.T) {
2206 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/symptomdata")
2209 func TestPostdeleteSubId(t *testing.T) {
2211 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/deletesubid=1")
2214 func TestPostEmptyDb(t *testing.T) {
2216 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/emptydb")
2219 //-----------------------------------------------------------------------------
2220 // TestRESTSubReqAndRouteNok
2223 // +-------+ +---------+ +---------+
2224 // | xapp | | submgr | | rtmgr |
2225 // +-------+ +---------+ +---------+
2228 // |---------------->| |
2230 // | RESTSubResp | |
2231 // |<----------------| |
2232 // | | RouteCreate |
2233 // | |------------->|
2235 // | | RouteCreate |
2237 // | |(Bad request) |
2238 // | |<-------------|
2240 // |<----------------| |
2242 // | [SUBS INT DELETE] |
2244 // | RESTSubDelReq | |
2245 // |---------------->| |
2246 // | RESTSubDelResp | |
2247 // |<----------------| |
2249 //-----------------------------------------------------------------------------
2250 func TestRESTSubReqAndRouteNok(t *testing.T) {
2251 CaseBegin("TestRESTSubReqAndRouteNok")
2253 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2254 Counter{cSubReqFromXapp, 1},
2255 Counter{cRouteCreateFail, 1},
2256 Counter{cSubRespToXapp, 1},
2257 Counter{cSubDelReqFromXapp, 1},
2258 Counter{cSubDelRespToXapp, 1},
2261 const subReqCount int = 1
2262 const parameterSet = 1
2263 const actionDefinitionPresent bool = true
2264 const actionParamCount int = 1
2265 // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
2266 waiter := rtmgrHttp.AllocNextSleep(50, false)
2267 newSubsId := mainCtrl.get_registry_next_subid(t)
2270 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2271 restSubId := xappConn1.SendRESTSubsReq(t, params)
2272 xappConn1.ExpectRESTNotification(t, restSubId)
2273 waiter.WaitResult(t)
2275 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2276 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
2279 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2281 // Wait that subs is cleaned
2282 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2283 waitSubsCleanup(t, e2SubsId, 10)
2284 mainCtrl.VerifyCounterValues(t)
2287 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
2288 CaseBegin("TestSubReqAndRouteUpdateNok")
2290 //Init counter check
2291 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2292 Counter{cSubReqFromXapp, 2},
2293 Counter{cSubReqToE2, 1},
2294 Counter{cSubRespFromE2, 1},
2295 Counter{cSubRespToXapp, 2},
2296 Counter{cRouteCreateUpdateFail, 1},
2297 Counter{cSubDelReqFromXapp, 1},
2298 Counter{cSubDelReqToE2, 1},
2299 Counter{cSubDelRespFromE2, 1},
2300 Counter{cSubDelRespToXapp, 1},
2303 var params *teststube2ap.RESTSubsReqParams = nil
2306 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2308 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2310 // xapp2 ROUTE creation shall fail with 400 from rtmgr -> submgr
2311 waiter := rtmgrHttp.AllocNextEvent(false)
2312 newSubsId := mainCtrl.get_registry_next_subid(t)
2313 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2314 params.SetMeid("RAN_NAME_1")
2315 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2316 xapp.Logger.Info("Send REST subscriber request for second subscriber : %v", restSubId2)
2317 xappConn2.ExpectRESTNotification(t, restSubId2)
2318 waiter.WaitResult(t)
2319 // e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) - TOD: missing delete
2320 xappConn2.WaitRESTNotification(t, restSubId2)
2322 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2324 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2326 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2327 //Wait that subs is cleaned
2328 waitSubsCleanup(t, e2SubsId, 10)
2330 mainCtrl.VerifyCounterValues(t)
2333 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
2334 CaseBegin("TestRESTSubDelReqAndRouteDeleteNok")
2336 // Init counter check
2337 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2338 Counter{cSubReqFromXapp, 1},
2339 Counter{cSubReqToE2, 1},
2340 Counter{cSubRespFromE2, 1},
2341 Counter{cSubRespToXapp, 1},
2342 Counter{cSubDelReqFromXapp, 1},
2343 Counter{cRouteDeleteFail, 1},
2344 Counter{cSubDelReqToE2, 1},
2345 Counter{cSubDelRespFromE2, 1},
2346 Counter{cSubDelRespToXapp, 1},
2349 var params *teststube2ap.RESTSubsReqParams = nil
2352 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2354 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2356 waiter := rtmgrHttp.AllocNextEvent(false)
2357 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2358 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2359 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2360 waiter.WaitResult(t)
2362 waitSubsCleanup(t, e2SubsId, 10)
2364 mainCtrl.VerifyCounterValues(t)
2367 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
2368 CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok")
2370 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2371 Counter{cSubReqFromXapp, 2},
2372 Counter{cSubReqToE2, 1},
2373 Counter{cSubRespFromE2, 1},
2374 Counter{cSubRespToXapp, 2},
2375 Counter{cSubDelReqFromXapp, 2},
2376 Counter{cRouteDeleteUpdateFail, 1},
2377 Counter{cSubDelReqToE2, 1},
2378 Counter{cSubDelRespFromE2, 1},
2379 Counter{cSubDelRespToXapp, 2},
2382 var params *teststube2ap.RESTSubsReqParams = nil
2385 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2387 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2388 restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1")
2390 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
2392 //Del1, this shall fail on rtmgr side
2393 waiter := rtmgrHttp.AllocNextEvent(false)
2394 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2395 waiter.WaitResult(t)
2397 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"})
2400 deleteXapp2Subscription(t, &restSubId2)
2402 waitSubsCleanup(t, e2SubsId2, 10)
2404 mainCtrl.VerifyCounterValues(t)
2407 //-----------------------------------------------------------------------------
2408 // TestRESTSubReqRetransmission
2411 // +-------+ +---------+ +---------+
2412 // | xapp | | submgr | | e2term |
2413 // +-------+ +---------+ +---------+
2415 // | RESTSubReq1 | |
2416 // |---------------->| |
2418 // | RESTSubResp | |
2419 // |<----------------| |
2421 // | |------------->|
2423 // | RESTSubReq2 | |
2425 // |---------------->| |
2428 // | |------------->|
2429 // | RESTSubResp2 | |
2430 // |<----------------| |
2432 // | |<-------------|
2434 // |<----------------| |
2436 // | |<-------------|
2438 // |<----------------| |
2440 // | [SUBS DELETE] |
2443 //-----------------------------------------------------------------------------
2445 func TestRESTSubReqRetransmission(t *testing.T) {
2446 CaseBegin("TestRESTSubReqRetransmission")
2448 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2449 Counter{cSubReqFromXapp, 2},
2450 Counter{cSubReqToE2, 2},
2451 Counter{cSubRespFromE2, 2},
2452 Counter{cSubRespToXapp, 2},
2453 Counter{cSubDelReqFromXapp, 2},
2454 Counter{cSubDelReqToE2, 2},
2455 Counter{cSubDelRespFromE2, 2},
2456 Counter{cSubDelRespToXapp, 2},
2458 // Retry/duplicate will get the same way as the first request. Submgr cannot detect duplicate RESTRequests
2459 // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
2460 // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
2463 const subReqCount int = 1
2464 const parameterSet = 1
2465 const actionDefinitionPresent bool = true
2466 const actionParamCount int = 1
2468 // In order to force both XAPP's to create their own subscriptions, force rtmgr to block a while so that 2nd create
2469 // gets into execution before the rtmgrg responds for the first one.
2470 waiter := rtmgrHttp.AllocNextSleep(10, true)
2471 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2472 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
2473 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2475 waiter.WaitResult(t)
2477 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
2479 // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
2480 // the order is not significant he6re.
2481 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2482 e2termConn1.SendSubsResp(t, crereq, cremsg)
2483 crereq, cremsg = e2termConn1.RecvSubsReq(t)
2484 e2termConn1.SendSubsResp(t, crereq, cremsg)
2486 e2SubsIdA := <-xappConn1.ListedRESTNotifications
2487 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
2488 e2SubsIdB := <-xappConn1.ListedRESTNotifications
2489 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
2492 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
2493 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2494 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2497 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
2498 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2499 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2501 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
2503 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
2505 mainCtrl.VerifyCounterValues(t)
2508 func TestRESTSubDelReqRetransmission(t *testing.T) {
2509 CaseBegin("TestRESTSubDelReqRetransmission")
2511 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2512 Counter{cSubReqFromXapp, 1},
2513 Counter{cSubReqToE2, 1},
2514 Counter{cSubRespFromE2, 1},
2515 Counter{cSubRespToXapp, 1},
2516 Counter{cSubDelReqFromXapp, 2},
2517 Counter{cSubDelReqToE2, 1},
2518 Counter{cSubDelRespFromE2, 1},
2519 Counter{cSubDelRespToXapp, 1},
2522 var params *teststube2ap.RESTSubsReqParams = nil
2525 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2527 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2530 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2531 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2533 seqBef := mainCtrl.get_msgcounter(t)
2534 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2535 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
2537 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2539 waitSubsCleanup(t, e2SubsId, 10)
2541 mainCtrl.VerifyCounterValues(t)
2544 //-----------------------------------------------------------------------------
2545 // TestRESTSubReqDelReq
2548 // +-------+ +---------+ +---------+
2549 // | xapp | | submgr | | e2term |
2550 // +-------+ +---------+ +---------+
2553 // |---------------->| |
2555 // | RESTSubResp | |
2556 // |<----------------| |
2558 // | |------------->|
2559 // | RESTSubDelReq | |
2560 // |---------------->| |
2561 // | RESTSubDelResp | |
2563 // |<----------------| |
2565 // | |<-------------|
2567 // |<----------------| |
2569 // | [SUBS DELETE] |
2572 //-----------------------------------------------------------------------------
2573 func TestRESTSubReqDelReq(t *testing.T) {
2574 CaseBegin("TestRESTSubReqDelReq")
2576 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2577 Counter{cSubReqFromXapp, 1},
2578 Counter{cSubReqToE2, 1},
2579 Counter{cSubRespFromE2, 1},
2580 Counter{cSubRespToXapp, 1},
2581 Counter{cSubDelReqFromXapp, 2},
2582 Counter{cSubDelReqToE2, 1},
2583 Counter{cSubDelRespFromE2, 1},
2584 Counter{cSubDelRespToXapp, 1},
2587 const subReqCount int = 1
2588 const parameterSet = 1
2589 const actionDefinitionPresent bool = true
2590 const actionParamCount int = 1
2593 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2594 restSubId := xappConn1.SendRESTSubsReq(t, params)
2596 // Del. This will fail as processing of the subscription
2597 // is still ongoing in submgr. Deletion is not allowed before
2598 // subscription creation has been completed.
2599 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2600 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2601 xappConn1.ExpectRESTNotification(t, restSubId)
2602 e2termConn1.SendSubsResp(t, crereq, cremsg)
2603 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2606 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2608 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2609 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2611 // Wait that subs is cleaned
2612 waitSubsCleanup(t, e2SubsId, 10)
2613 mainCtrl.VerifyCounterValues(t)
2617 func TestRESTSubDelReqCollision(t *testing.T) {
2618 CaseBegin("TestRESTSubDelReqCollision - not relevant for REST API")
2621 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
2622 CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel")
2624 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2625 Counter{cSubReqFromXapp, 2},
2626 Counter{cSubReqToE2, 2},
2627 Counter{cSubRespFromE2, 2},
2628 Counter{cSubRespToXapp, 2},
2629 Counter{cSubDelReqFromXapp, 2},
2630 Counter{cSubDelReqToE2, 2},
2631 Counter{cSubDelRespFromE2, 2},
2632 Counter{cSubDelRespToXapp, 2},
2636 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2637 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
2638 xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
2641 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2642 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2643 xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
2645 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2646 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
2648 //XappConn1 receives both of the responses
2649 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
2652 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2654 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
2656 e2SubsIdA := <-xappConn1.ListedRESTNotifications
2657 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
2658 e2SubsIdB := <-xappConn1.ListedRESTNotifications
2659 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
2662 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
2664 deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
2666 //Wait that subs is cleaned
2667 mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
2668 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
2670 mainCtrl.VerifyCounterValues(t)
2674 func TestRESTSameSubsDiffRan(t *testing.T) {
2675 CaseBegin("TestRESTSameSubsDiffRan")
2677 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2678 Counter{cSubReqFromXapp, 2},
2679 Counter{cSubReqToE2, 2},
2680 Counter{cSubRespFromE2, 2},
2681 Counter{cSubRespToXapp, 2},
2682 Counter{cSubDelReqFromXapp, 2},
2683 Counter{cSubDelReqToE2, 2},
2684 Counter{cSubDelRespFromE2, 2},
2685 Counter{cSubDelRespToXapp, 2},
2688 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2689 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
2690 xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
2692 params = xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2693 params.SetMeid("RAN_NAME_2")
2694 restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
2695 xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
2698 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
2700 deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
2702 //Wait that subs is cleaned
2703 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
2704 waitSubsCleanup(t, e2SubsId2, 10)
2706 mainCtrl.VerifyCounterValues(t)
2710 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
2711 CaseBegin("TestRESTSubReqRetryInSubmgr start")
2713 // Init counter check
2714 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2715 Counter{cSubReqFromXapp, 1},
2716 Counter{cSubReqToE2, 1},
2717 Counter{cSubReReqToE2, 1},
2718 Counter{cSubRespFromE2, 1},
2719 Counter{cSubRespToXapp, 1},
2720 Counter{cSubDelReqFromXapp, 1},
2721 Counter{cSubDelReqToE2, 1},
2722 Counter{cSubDelRespFromE2, 1},
2723 Counter{cSubDelRespToXapp, 1},
2726 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2727 restSubId := xappConn1.SendRESTSubsReq(t, params)
2729 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
2731 // Catch the first message and ignore it
2732 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2733 xapp.Logger.Info("Ignore REST subscriber request for subscriber : %v", restSubId)
2735 // The second request is being handled normally
2736 crereq, cremsg = e2termConn1.RecvSubsReq(t)
2737 xappConn1.ExpectRESTNotification(t, restSubId)
2738 e2termConn1.SendSubsResp(t, crereq, cremsg)
2739 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2741 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2743 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2745 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2746 //Wait that subs is cleaned
2747 waitSubsCleanup(t, e2SubsId, 10)
2749 mainCtrl.VerifyCounterValues(t)
2753 //-----------------------------------------------------------------------------
2754 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
2757 // +-------+ +---------+ +---------+
2758 // | xapp | | submgr | | e2term |
2759 // +-------+ +---------+ +---------+
2762 // |---------------->| |
2764 // | RESTSubResp | |
2765 // |<----------------| |
2767 // | |------------->|
2771 // | |------------->|
2774 // | |------------->|
2778 // | |------------->|
2782 // | |<-------------|
2785 // |<----------------| |
2787 // | [SUBS DELETE] |
2790 //-----------------------------------------------------------------------------
2791 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
2792 CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
2794 // Init counter check
2795 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2796 Counter{cSubReqFromXapp, 1},
2797 Counter{cSubReqToE2, 1},
2798 Counter{cSubReReqToE2, 1},
2799 Counter{cSubReqTimerExpiry, 2},
2800 Counter{cSubDelReqToE2, 1},
2801 Counter{cSubDelRespFromE2, 1},
2804 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2805 restSubId := xappConn1.SendRESTSubsReq(t, params)
2806 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
2808 e2termConn1.RecvSubsReq(t)
2809 xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
2811 e2termConn1.RecvSubsReq(t)
2812 xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
2814 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2815 xappConn1.ExpectRESTNotification(t, restSubId)
2816 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2817 // e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) - TODO: Should we delete this?
2818 xappConn1.WaitRESTNotification(t, restSubId)
2820 // Wait that subs is cleaned
2821 waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
2823 mainCtrl.VerifyCounterValues(t)
2826 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
2827 CaseBegin("TestREST2eTermNotRespondingToSubReq start")
2829 // Init counter check
2830 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2831 Counter{cSubReqFromXapp, 1},
2832 Counter{cSubReqToE2, 1},
2833 Counter{cSubReReqToE2, 1},
2834 Counter{cSubReqTimerExpiry, 2},
2835 Counter{cSubDelReqToE2, 1},
2836 Counter{cSubDelReqTimerExpiry, 2},
2839 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2840 restSubId := xappConn1.SendRESTSubsReq(t, params)
2841 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
2843 e2termConn1.RecvSubsReq(t)
2844 xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
2846 e2termConn1.RecvSubsReq(t)
2847 xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
2849 e2termConn1.RecvSubsDelReq(t)
2850 xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
2852 xappConn1.ExpectRESTNotification(t, restSubId)
2853 e2termConn1.RecvSubsDelReq(t)
2854 xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
2856 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2858 waitSubsCleanup(t, e2SubsId, 10)
2860 mainCtrl.VerifyCounterValues(t)
2864 //-----------------------------------------------------------------------------
2865 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
2868 // +-------+ +---------+ +---------+
2869 // | xapp | | submgr | | e2term |
2870 // +-------+ +---------+ +---------+
2873 // |---------------->| |
2875 // | RESTSubResp | |
2876 // |<----------------| |
2878 // | |------------->|
2882 // | |------------->|
2885 // | |------------->|
2889 // | |------------->|
2893 // | |<-------------|
2896 // |<----------------| |
2898 // | [SUBS DELETE] |
2901 //-----------------------------------------------------------------------------
2902 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
2903 CaseBegin("TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr start")
2905 // Init counter check
2906 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2907 Counter{cSubReqFromXapp, 1},
2908 Counter{cSubReqToE2, 1},
2909 Counter{cSubReReqToE2, 1},
2910 Counter{cSubReqTimerExpiry, 2},
2911 Counter{cSubDelReqToE2, 1},
2912 Counter{cSubDelReReqToE2, 1},
2913 Counter{cSubDelReqTimerExpiry, 2},
2916 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2917 restSubId := xappConn1.SendRESTSubsReq(t, params)
2918 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
2920 e2termConn1.RecvSubsReq(t)
2921 xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
2923 e2termConn1.RecvSubsReq(t)
2924 xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
2926 e2termConn1.RecvSubsDelReq(t)
2927 xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
2929 xappConn1.ExpectRESTNotification(t, restSubId)
2930 e2termConn1.RecvSubsDelReq(t)
2931 xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
2933 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2935 waitSubsCleanup(t, e2SubsId, 10)
2937 mainCtrl.VerifyCounterValues(t)
2940 //-----------------------------------------------------------------------------
2941 // TestRESTSubReqSubFailRespInSubmgr
2944 // +-------+ +---------+ +---------+
2945 // | xapp | | submgr | | e2term |
2946 // +-------+ +---------+ +---------+
2949 // |---------------->| |
2951 // | RESTSubResp | |
2952 // |<----------------| |
2954 // | |------------->|
2957 // | |<-------------|
2960 // | |------------->|
2963 // | |<-------------|
2967 // |<----------------| |
2969 // | [SUBS DELETE] |
2972 //-----------------------------------------------------------------------------
2973 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
2974 CaseBegin("TestRESTSubReqSubFailRespInSubmgr")
2976 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2977 Counter{cSubReqFromXapp, 1},
2978 Counter{cSubReqToE2, 1},
2979 Counter{cSubFailFromE2, 1},
2980 Counter{cSubRespToXapp, 1},
2981 Counter{cSubDelReqFromXapp, 1},
2984 const subReqCount int = 1
2985 const parameterSet = 1
2986 const actionDefinitionPresent bool = true
2987 const actionParamCount int = 1
2989 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
2990 restSubId := xappConn1.SendRESTSubsReq(t, params)
2992 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2993 fparams1 := &teststube2ap.E2StubSubsFailParams{}
2994 fparams1.Set(crereq1)
2995 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
2997 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2998 xappConn1.ExpectRESTNotification(t, restSubId)
2999 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3000 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3001 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
3003 // REST subscription sill there to be deleted
3004 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3006 // Wait that subs is cleaned
3007 waitSubsCleanup(t, e2SubsId, 10)
3009 mainCtrl.VerifyCounterValues(t)
3013 //-----------------------------------------------------------------------------
3014 // TestRESTSubDelReqRetryInSubmgr
3017 // +-------+ +---------+ +---------+
3018 // | xapp | | submgr | | e2term |
3019 // +-------+ +---------+ +---------+
3021 // | [SUBS CREATE] |
3024 // | RESTSubDelReq | |
3025 // |---------------->| |
3027 // | RESTSubDelResp | |
3028 // |<----------------| |
3030 // | |------------->|
3033 // | |------------->|
3036 // | |<-------------|
3039 //-----------------------------------------------------------------------------
3040 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
3041 CaseBegin("TestRESTSubDelReqRetryInSubmgr")
3043 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3044 Counter{cSubReqFromXapp, 1},
3045 Counter{cSubReqToE2, 1},
3046 Counter{cSubRespFromE2, 1},
3047 Counter{cSubRespToXapp, 1},
3048 Counter{cSubDelReqFromXapp, 1},
3049 Counter{cSubDelReqToE2, 1},
3050 Counter{cSubDelReReqToE2, 1},
3051 Counter{cSubDelRespFromE2, 1},
3052 Counter{cSubDelRespToXapp, 1},
3055 var params *teststube2ap.RESTSubsReqParams = nil
3056 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3059 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3061 // E2t: Receive 1st SubsDelReq
3062 e2termConn1.RecvSubsDelReq(t)
3064 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
3065 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3066 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3068 //Wait that subs is cleaned
3069 waitSubsCleanup(t, e2SubsId, 10)
3071 mainCtrl.VerifyCounterValues(t)
3074 //-----------------------------------------------------------------------------
3075 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
3078 // +-------+ +---------+ +---------+
3079 // | xapp | | submgr | | e2term |
3080 // +-------+ +---------+ +---------+
3082 // | [SUBS CREATE] |
3085 // | RESTSubDelReq | |
3086 // |---------------->| |
3088 // | RESTSubDelResp | |
3089 // |<----------------| |
3091 // | |------------->|
3094 // | |------------->|
3098 //-----------------------------------------------------------------------------
3099 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
3100 CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr")
3102 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3103 Counter{cSubReqFromXapp, 1},
3104 Counter{cSubReqToE2, 1},
3105 Counter{cSubRespFromE2, 1},
3106 Counter{cSubRespToXapp, 1},
3107 Counter{cSubDelReqFromXapp, 1},
3108 Counter{cSubDelReqToE2, 1},
3109 Counter{cSubDelReReqToE2, 1},
3110 Counter{cSubDelRespFromE2, 1},
3111 Counter{cSubDelRespToXapp, 1},
3115 var params *teststube2ap.RESTSubsReqParams = nil
3116 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3119 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3121 // E2t: Receive 1st SubsDelReq
3122 e2termConn1.RecvSubsDelReq(t)
3124 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
3125 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3126 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3128 //Wait that subs is cleaned
3129 waitSubsCleanup(t, e2SubsId, 10)
3131 mainCtrl.VerifyCounterValues(t)
3134 //-----------------------------------------------------------------------------
3135 // TestRESTSubDelReqSubDelFailRespInSubmgr
3138 // +-------+ +---------+ +---------+
3139 // | xapp | | submgr | | e2term |
3140 // +-------+ +---------+ +---------+
3142 // | [SUBS CREATE] |
3145 // | RESTSubDelReq | |
3146 // |---------------->| |
3148 // | RESTSubDelResp | |
3149 // |<----------------| |
3151 // | |------------->|
3154 // | |<-------------|
3157 //-----------------------------------------------------------------------------
3158 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
3159 CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr")
3161 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3162 Counter{cSubReqFromXapp, 1},
3163 Counter{cSubReqToE2, 1},
3164 Counter{cSubRespFromE2, 1},
3165 Counter{cSubRespToXapp, 1},
3166 Counter{cSubDelReqFromXapp, 1},
3167 Counter{cSubDelReqToE2, 1},
3168 Counter{cSubDelFailFromE2, 1},
3169 Counter{cSubDelRespToXapp, 1},
3173 var params *teststube2ap.RESTSubsReqParams = nil
3174 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3177 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3179 // E2t: Send receive SubsDelReq and send SubsDelFail
3180 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3181 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
3183 //Wait that subs is cleaned
3184 waitSubsCleanup(t, e2SubsId, 10)
3186 mainCtrl.VerifyCounterValues(t)
3189 //-----------------------------------------------------------------------------
3190 // TestRESTSubReqAndSubDelOkSameAction
3193 // +-------+ +-------+ +---------+ +---------+
3194 // | xapp2 | | xapp1 | | submgr | | e2term |
3195 // +-------+ +-------+ +---------+ +---------+
3197 // | | RESTSubReq1 | |
3198 // | |---------------->| |
3200 // | | RESTSubResp1 | |
3201 // | |<----------------| |
3204 // | | |------------->|
3206 // | | |<-------------|
3207 // | | RESTNotif1 | |
3208 // | |<----------------| |
3210 // | RESTSubReq2 | |
3211 // |------------------------------>| |
3213 // | RESTSubResp2 | |
3214 // |<------------------------------| |
3216 // | | RESTNotif2 | |
3217 // |<------------------------------| |
3219 // | | RESTSubDelReq1 | |
3220 // | |---------------->| |
3222 // | | RESTSubDelResp1 | |
3223 // | |<----------------| |
3225 // | RESTSubDelReq2 | |
3226 // |------------------------------>| |
3228 // | RESTSubDelResp2 | |
3229 // |<------------------------------| |
3231 // | | | SubDelReq2 |
3232 // | | |------------->|
3234 // | | | SubDelResp2 |
3235 // | | |<-------------|
3238 //-----------------------------------------------------------------------------
3239 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
3240 CaseBegin("TestRESTSubReqAndSubDelOkSameAction")
3242 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3243 Counter{cSubReqFromXapp, 2},
3244 Counter{cSubReqToE2, 1},
3245 Counter{cSubRespFromE2, 1},
3246 Counter{cSubRespToXapp, 2},
3247 Counter{cMergedSubscriptions, 1},
3248 Counter{cUnmergedSubscriptions, 1},
3249 Counter{cSubDelReqFromXapp, 2},
3250 Counter{cSubDelReqToE2, 1},
3251 Counter{cSubDelRespFromE2, 1},
3252 Counter{cSubDelRespToXapp, 2},
3256 var params *teststube2ap.RESTSubsReqParams = nil
3259 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3260 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
3263 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3264 params.SetMeid("RAN_NAME_1")
3266 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
3267 xappConn2.WaitRESTNotificationForAnySubscriptionId(t)
3268 waiter := rtmgrHttp.AllocNextSleep(10, true)
3269 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3270 waiter.WaitResult(t)
3271 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
3272 e2SubsId2 := <-xappConn2.RESTNotification
3273 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
3275 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
3278 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3281 deleteXapp2Subscription(t, &restSubId2)
3283 //Wait that subs is cleaned
3284 waitSubsCleanup(t, e2SubsId2, 10)
3286 mainCtrl.VerifyCounterValues(t)
3289 //-----------------------------------------------------------------------------
3290 // TestSubReqAndSubDelOkSameActionParallel
3293 // +-------+ +-------+ +---------+ +---------+
3294 // | xapp2 | | xapp1 | | submgr | | e2term |
3295 // +-------+ +-------+ +---------+ +---------+
3300 // | |------------->| |
3303 // | | |------------->|
3305 // |--------------------------->| |
3307 // | | |<-------------|
3309 // | |<-------------| |
3311 // | | |------------->|
3314 // | | |<-------------|
3316 // |<---------------------------| |
3318 // | | SubDelReq 1 | |
3319 // | |------------->| |
3321 // | | SubDelResp 1 | |
3322 // | |<-------------| |
3324 // | SubDelReq 2 | |
3325 // |--------------------------->| |
3327 // | | | SubDelReq 2 |
3328 // | | |------------->|
3330 // | | | SubDelReq 2 |
3331 // | | |------------->|
3333 // | SubDelResp 2 | |
3334 // |<---------------------------| |
3336 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
3337 CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel")
3339 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3340 Counter{cSubReqFromXapp, 2},
3341 Counter{cSubReqToE2, 2},
3342 Counter{cSubRespFromE2, 2},
3343 Counter{cSubRespToXapp, 2},
3344 Counter{cSubDelReqFromXapp, 2},
3345 Counter{cSubDelReqToE2, 2},
3346 Counter{cSubDelRespFromE2, 2},
3347 Counter{cSubDelRespToXapp, 2},
3350 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3351 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3352 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3354 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3355 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
3357 xappConn1.ExpectRESTNotification(t, restSubId1)
3358 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3359 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
3361 xappConn2.ExpectRESTNotification(t, restSubId2)
3362 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3363 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3364 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
3367 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3368 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3369 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3370 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3373 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
3374 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
3375 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
3377 waitSubsCleanup(t, e2SubsId2, 10)
3379 mainCtrl.VerifyCounterValues(t)
3382 //-----------------------------------------------------------------------------
3383 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
3386 // +-------+ +-------+ +---------+ +---------+
3387 // | xapp2 | | xapp1 | | submgr | | e2term |
3388 // +-------+ +-------+ +---------+ +---------+
3392 // | | RESTSubReq1 | |
3393 // | |---------------->| |
3395 // | | RESTSubResp1 | |
3396 // | |<----------------| |
3398 // | | |------------->|
3399 // | RESTSubReq2 | |
3400 // |------------------------------>| |
3402 // | RESTSubDelResp2 | |
3403 // |<------------------------------| |
3405 // | | |------------->|
3408 // | | | SubDelReq |
3409 // | | |------------->|
3411 // | | | SubDelResp |
3412 // | | |<-------------|
3413 // | | RESTNotif1 | |
3414 // | | unsuccess | |
3415 // | |<----------------| |
3417 // | | unsuccess | |
3418 // |<------------------------------| |
3420 // | | RESTSubDelReq1 | |
3421 // | |---------------->| |
3423 // | | RESTSubDelResp1 | |
3424 // | |<----------------| |
3426 // | RESTSubDelReq2 | |
3427 // |------------------------------>| |
3429 // | RESTSubDelResp2 | |
3430 // |<------------------------------| |
3432 //-----------------------------------------------------------------------------
3433 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
3434 CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
3436 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3437 Counter{cSubReqFromXapp, 2},
3438 Counter{cSubReqToE2, 1},
3439 Counter{cSubRespToXapp, 2},
3440 Counter{cSubDelReqFromXapp, 2},
3441 Counter{cSubDelReqToE2, 1},
3442 Counter{cSubDelRespFromE2, 1},
3443 Counter{cSubDelRespToXapp, 2},
3446 const subReqCount int = 1
3447 const parameterSet = 1
3448 const actionDefinitionPresent bool = true
3449 const actionParamCount int = 1
3452 params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3453 restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
3454 crereq1, _ := e2termConn1.RecvSubsReq(t)
3457 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
3458 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3459 params2.SetMeid("RAN_NAME_1")
3460 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
3461 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
3463 //Req1 (retransmitted)
3464 e2termConn1.RecvSubsReq(t)
3466 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3468 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3469 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3471 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3472 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3473 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3474 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3477 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3480 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
3482 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
3484 //Wait that subs is cleaned
3485 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
3487 mainCtrl.VerifyCounterValues(t)
3490 //-----------------------------------------------------------------------------
3491 // TestRESTSubReqAndSubDelNokSameActionParallel
3494 // +-------+ +-------+ +---------+ +---------+
3495 // | xapp2 | | xapp1 | | submgr | | e2term |
3496 // +-------+ +-------+ +---------+ +---------+
3500 // | | RESTSubReq1 | |
3501 // | |---------------->| |
3503 // | | RESTSubResp1 | |
3504 // | |<----------------| |
3506 // | | |------------->|
3507 // | RESTSubReq2 | |
3508 // |------------------------------>| |
3510 // | RESTSubDelResp2 | |
3511 // |<------------------------------| |
3513 // | | |<-------------|
3515 // | | RESTNotif1 | |
3516 // | | unsuccess | |
3517 // | |<----------------| |
3519 // | | unsuccess | |
3520 // |<------------------------------| |
3521 // | | | SubDelReq |
3522 // | | |------------->|
3523 // | | | SubDelResp |
3524 // | | |<-------------|
3526 // | | RESTSubDelReq1 | |
3527 // | |---------------->| |
3529 // | | RESTSubDelResp1 | |
3530 // | |<----------------| |
3532 // | RESTSubDelReq2 | |
3533 // |------------------------------>| |
3535 // | RESTSubDelResp2 | |
3536 // |<------------------------------| |
3538 //-----------------------------------------------------------------------------
3539 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
3540 CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
3542 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3543 Counter{cSubReqFromXapp, 2},
3544 Counter{cSubReqToE2, 1},
3545 Counter{cSubFailFromE2, 1},
3546 Counter{cSubRespToXapp, 2},
3547 Counter{cSubDelReqFromXapp, 2},
3548 Counter{cSubDelReqToE2, 1},
3549 Counter{cSubDelRespFromE2, 1},
3550 Counter{cSubDelRespToXapp, 2},
3553 const subReqCount int = 1
3554 const parameterSet = 1
3555 const actionDefinitionPresent bool = true
3556 const actionParamCount int = 1
3559 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3560 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3561 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3564 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
3565 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3566 params2.SetMeid("RAN_NAME_1")
3567 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
3568 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
3570 // E2t: send SubsFail (first)
3571 fparams1 := &teststube2ap.E2StubSubsFailParams{}
3572 fparams1.Set(crereq1)
3573 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3575 // E2t: internal delete
3576 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3577 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3578 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3580 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3581 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3582 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3583 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3586 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3589 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
3591 //Wait that subs is cleaned
3592 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
3593 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
3595 mainCtrl.VerifyCounterValues(t)
3598 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
3599 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
3601 // Init counter check
3602 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3603 Counter{cSubReqFromXapp, 1},
3604 Counter{cSubReqToE2, 1},
3605 Counter{cSubRespFromE2, 1},
3606 Counter{cSubRespToXapp, 1},
3607 Counter{cSubDelReqFromXapp, 1},
3608 Counter{cSubDelReqToE2, 1},
3609 Counter{cSubDelRespFromE2, 1},
3610 Counter{cSubDelRespToXapp, 1},
3613 const subReqCount int = 1
3614 const parameterSet = 1
3615 const actionDefinitionPresent bool = true
3616 const actionParamCount int = 1
3618 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
3619 restSubId := xappConn1.SendRESTSubsReq(t, params)
3620 xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
3622 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3623 xappConn1.ExpectRESTNotification(t, restSubId)
3624 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3625 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3626 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
3628 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3629 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3630 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3632 // Wait that subs is cleaned
3633 waitSubsCleanup(t, e2SubsId, 10)
3634 mainCtrl.VerifyCounterValues(t)
3637 //-----------------------------------------------------------------------------
3638 // TestRESTSubReqPolicyChangeAndSubDelOk
3641 // +-------+ +---------+ +---------+
3642 // | xapp | | submgr | | e2term |
3643 // +-------+ +---------+ +---------+
3646 // |---------------->| |
3648 // | RESTSubResp | |
3649 // |<----------------| |
3651 // | |------------->|
3654 // | |<-------------|
3657 // |<----------------| |
3660 // |---------------->| |
3662 // | RESTSubResp | |
3663 // |<----------------| |
3665 // | |------------->|
3668 // | |<-------------|
3671 // |<----------------| |
3673 // | RESTSubDelReq | |
3674 // |---------------->| |
3677 // | |------------->|
3680 // | |<-------------|
3682 // | RESTSubDelResp | |
3683 // |<----------------| |
3685 //-----------------------------------------------------------------------------
3686 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
3687 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
3689 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3690 Counter{cSubReqFromXapp, 2},
3691 Counter{cSubReqToE2, 2},
3692 Counter{cSubRespFromE2, 2},
3693 Counter{cSubRespToXapp, 2},
3694 Counter{cSubDelReqFromXapp, 1},
3695 Counter{cSubDelReqToE2, 1},
3696 Counter{cSubDelRespFromE2, 1},
3697 Counter{cSubDelRespToXapp, 1},
3700 const subReqCount int = 1
3701 const parameterSet = 1
3702 const actionDefinitionPresent bool = true
3703 const policyParamCount int = 1
3706 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
3707 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3710 instanceId := int64(e2SubsId)
3711 // GetRESTSubsReqPolicyParams sets some coutners on tc side.
3712 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
3713 params.SubsReqParams.SubscriptionDetails[0].InstanceID = &instanceId
3714 params.SetTimeToWait("w200ms")
3715 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
3718 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3720 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3721 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3723 // Wait that subs is cleaned
3724 waitSubsCleanup(t, e2SubsId, 10)
3725 mainCtrl.VerifyCounterValues(t)
3728 //-----------------------------------------------------------------------------
3729 // TestRESTSubReqAndSubDelOkTwoE2termParallel
3732 // +-------+ +---------+ +---------+ +---------+
3733 // | xapp | | submgr | | e2term1 | | e2term2 |
3734 // +-------+ +---------+ +---------+ +---------+
3738 // | RESTSubReq1 | | |
3739 // |---------------->| | |
3741 // | RESTSubResp1 | | |
3742 // |<----------------| | |
3744 // | |------------->| |
3746 // | RESTSubReq2 | | |
3747 // |---------------->| | |
3749 // | RESTSubResp2 | | |
3750 // |<----------------| | |
3752 // | |---------------------------->|
3755 // | |<-------------| |
3756 // | RESTNotif1 | | |
3757 // |<----------------| | |
3759 // | |<----------------------------|
3760 // | RESTNotif2 | | |
3761 // |<----------------| | |
3763 // | [SUBS 1 DELETE] | |
3765 // | [SUBS 2 DELETE] | |
3768 //-----------------------------------------------------------------------------
3769 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
3770 CaseBegin("TestRESTSubReqAndSubDelOkTwoE2termParallel")
3772 // Init counter check
3773 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3774 Counter{cSubReqFromXapp, 2},
3775 Counter{cSubReqToE2, 2},
3776 Counter{cSubRespFromE2, 2},
3777 Counter{cSubRespToXapp, 2},
3778 Counter{cSubDelReqFromXapp, 2},
3779 Counter{cSubDelReqToE2, 2},
3780 Counter{cSubDelRespFromE2, 2},
3781 Counter{cSubDelRespToXapp, 2},
3784 const subReqCount int = 1
3785 const parameterSet = 1
3786 const actionDefinitionPresent bool = true
3787 const actionParamCount int = 1
3790 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3791 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3792 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3795 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3796 params.SetMeid("RAN_NAME_11")
3797 // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
3798 // would not work as notification would not be received
3799 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3800 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
3803 xappConn1.ExpectRESTNotification(t, restSubId1)
3804 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3805 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
3806 xapp.Logger.Info("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
3809 xappConn2.ExpectRESTNotification(t, restSubId2)
3810 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
3811 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
3812 xapp.Logger.Info("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
3815 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3816 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3817 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3819 // Wait that subs is cleaned
3820 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3823 xappConn1.SendRESTSubsDelReq(t, &restSubId2)
3824 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
3825 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
3827 // Wait that subs is cleaned
3828 waitSubsCleanup(t, e2SubsId2, 10)
3830 mainCtrl.VerifyCounterValues(t)
3833 //-----------------------------------------------------------------------------
3834 // TestRESTSubReqAsn1EncodeFail
3836 // In this case submgr send RICSubscriptionDeleteRequest after encode failure which should not happen!
3838 // +-------+ +---------+ +---------+
3839 // | xapp | | submgr | | e2term |
3840 // +-------+ +---------+ +---------+
3843 // |---------------->| |
3845 // | RESTSubResp | |
3846 // |<----------------| |
3847 // | RESTSubDelReq | |
3848 // |---------------->| |
3849 // | RESTSubDelResp | |
3851 // |<----------------| |
3854 //-----------------------------------------------------------------------------
3855 func TestRESTSubReqAsn1EncodeFail(t *testing.T) {
3856 CaseBegin("TestRESTSubReqAsn1EncodeFail")
3858 xapp.Logger.Info("Xapp-frame, v0.8.1 sufficient REST API validation")
3862 //-----------------------------------------------------------------------------
3863 // TestRESTSubReqInsertAndSubDelOk
3866 // +-------+ +---------+ +---------+
3867 // | xapp | | submgr | | e2term |
3868 // +-------+ +---------+ +---------+
3871 // |---------------->| |
3873 // | RESTSubResp | |
3874 // |<----------------| |
3877 // | |------------->|
3880 // | |<-------------|
3882 // |<----------------| |
3885 // | RESTSubDelReq | |
3886 // |---------------->| |
3889 // | |------------->|
3892 // | |<-------------|
3894 // | RESTSubDelResp| |
3895 // |<----------------| |
3897 //-----------------------------------------------------------------------------
3898 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
3899 CaseBegin("TestRESTInsertSubReqAndSubDelOk")
3901 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3902 Counter{cSubReqFromXapp, 1},
3903 Counter{cSubReqToE2, 1},
3904 Counter{cSubRespFromE2, 1},
3905 Counter{cSubRespToXapp, 1},
3906 Counter{cSubDelReqFromXapp, 1},
3907 Counter{cSubDelReqToE2, 1},
3908 Counter{cSubDelRespFromE2, 1},
3909 Counter{cSubDelRespToXapp, 1},
3912 const subReqCount int = 1
3913 const parameterSet int = 1
3914 const actionDefinitionPresent bool = true
3915 const actionParamCount int = 1
3917 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3918 params.SetSubActionTypes("insert")
3921 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3924 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3926 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3927 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3929 // Wait that subs is cleaned
3930 waitSubsCleanup(t, e2SubsId, 10)
3931 mainCtrl.VerifyCounterValues(t)
3934 //-----------------------------------------------------------------------------
3935 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
3938 // +-------+ +---------+ +---------+
3939 // | xapp | | submgr | | e2term |
3940 // +-------+ +---------+ +---------+
3943 // |------------->| |
3946 // | |------------->|
3951 // | Submgr restart |
3955 // | |------------->|
3958 // | |<-------------|
3961 //-----------------------------------------------------------------------------
3962 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
3963 CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle")
3965 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3966 Counter{cSubReqFromXapp, 1},
3967 Counter{cSubReqToE2, 1},
3968 Counter{cSubDelReqFromXapp, 1},
3969 Counter{cSubDelReqToE2, 1},
3970 Counter{cSubDelRespFromE2, 1},
3973 const subReqCount int = 1
3974 const parameterSet = 1
3975 const actionDefinitionPresent bool = true
3976 const actionParamCount int = 1
3978 // Remove possible existing subscription
3979 mainCtrl.removeExistingSubscriptions(t)
3981 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
3984 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
3985 restSubId := xappConn1.SendRESTSubsReq(t, params)
3986 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
3988 e2termConn1.RecvSubsReq(t)
3990 mainCtrl.SetResetTestFlag(t, false)
3992 mainCtrl.SimulateRestart(t)
3993 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
3996 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3997 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3999 xappConn1.TestMsgChanEmpty(t)
4000 xappConn2.TestMsgChanEmpty(t)
4001 e2termConn1.TestMsgChanEmpty(t)
4002 mainCtrl.wait_registry_empty(t, 10)
4004 mainCtrl.VerifyCounterValues(t)
4007 //-----------------------------------------------------------------------------
4008 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
4011 // +-------+ +---------+ +---------+
4012 // | xapp | | submgr | | e2term |
4013 // +-------+ +---------+ +---------+
4016 // |---------------->| |
4018 // | RESTSubResp | |
4019 // |<----------------| |
4021 // | |------------->|
4024 // | |<-------------|
4027 // |<----------------| |
4030 // | Submgr restart |
4032 // | RESTSubDelReq | |
4033 // |---------------->| |
4036 // | |------------->|
4039 // | |<-------------|
4041 // | RESTSubDelResp | |
4042 // |<----------------| |
4044 //-----------------------------------------------------------------------------
4045 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
4046 CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle")
4048 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4049 Counter{cSubReqFromXapp, 1},
4050 Counter{cSubReqToE2, 1},
4051 Counter{cSubRespFromE2, 1},
4052 Counter{cSubRespToXapp, 1},
4053 Counter{cSubDelReqFromXapp, 1},
4054 Counter{cSubDelReqToE2, 1},
4055 Counter{cSubDelRespToXapp, 1},
4058 // Remove possible existing subscription
4059 mainCtrl.removeExistingSubscriptions(t)
4061 var params *teststube2ap.RESTSubsReqParams = nil
4063 // Create subscription
4064 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4065 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
4067 // Check subscription
4068 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4070 // When SDL support for the REST Interface is added
4071 // the submgr restart statement below should be removed
4072 // from the comment.
4074 // mainCtrl.SimulateRestart(t)
4075 // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4077 // Check subscription
4078 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4080 // Delete subscription
4081 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
4083 //Wait that subs is cleaned
4084 waitSubsCleanup(t, e2SubsId, 10)
4086 mainCtrl.VerifyCounterValues(t)
4089 //-----------------------------------------------------------------------------
4090 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
4093 // +-------+ +-------+ +---------+ +---------+
4094 // | xapp2 | | xapp1 | | submgr | | e2term |
4095 // +-------+ +-------+ +---------+ +---------+
4097 // | | RESTSubReq1 | |
4098 // | |---------------->| |
4100 // | | RESTSubResp1 | |
4101 // | |<----------------| |
4104 // | | |------------->|
4106 // | | |<-------------|
4107 // | | RESTNotif1 | |
4108 // | |<----------------| |
4110 // | RESTSubReq2 | |
4111 // |------------------------------>| |
4113 // | RESTSubResp2 | |
4114 // |<------------------------------| |
4116 // | | RESTNotif2 | |
4117 // |<------------------------------| |
4119 // | | Submgr restart |
4121 // | | RESTSubDelReq1 | |
4122 // | |---------------->| |
4124 // | | RESTSubDelResp1 | |
4125 // | |<----------------| |
4127 // | | Submgr restart |
4129 // | RESTSubDelReq2 | |
4130 // |------------------------------>| |
4132 // | RESTSubDelResp2 | |
4133 // |<------------------------------| |
4135 // | | | SubDelReq2 |
4136 // | | |------------->|
4138 // | | | SubDelResp2 |
4139 // | | |<-------------|
4142 //-----------------------------------------------------------------------------
4143 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
4144 CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
4146 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4147 Counter{cSubReqFromXapp, 2},
4148 Counter{cSubReqToE2, 1},
4149 Counter{cSubRespFromE2, 1},
4150 Counter{cSubRespToXapp, 2},
4151 Counter{cMergedSubscriptions, 1},
4152 Counter{cUnmergedSubscriptions, 1},
4153 Counter{cSubDelReqFromXapp, 2},
4154 Counter{cSubDelReqToE2, 1},
4155 Counter{cSubDelRespFromE2, 1},
4156 Counter{cSubDelRespToXapp, 2},
4159 // Remove possible existing subscription
4160 mainCtrl.removeExistingSubscriptions(t)
4162 var params *teststube2ap.RESTSubsReqParams = nil
4164 // Create subscription 1
4165 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4166 xapp.Logger.Info("Send REST subscriber request for subscriber 1 : %v", restSubId1)
4168 // Create subscription 2 with same action
4169 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4170 params.SetMeid("RAN_NAME_1")
4171 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4172 xappConn2.WaitRESTNotificationForAnySubscriptionId(t)
4173 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4174 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4175 e2SubsId2 := <-xappConn2.RESTNotification
4176 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
4178 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
4180 // When SDL support for the REST Interface is added
4181 // the submgr restart statement below should be removed
4182 // from the comment.
4184 // mainCtrl.SimulateRestart(t)
4185 // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4187 // Delete subscription 1, and wait until it has removed the first endpoint
4188 subepcnt := mainCtrl.get_subs_entrypoint_cnt(t, e2SubsId1)
4189 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4190 mainCtrl.wait_subs_entrypoint_cnt_change(t, e2SubsId1, subepcnt, 10)
4192 // When SDL support for the REST Interface is added
4193 // the submgr restart statement below should be removed
4194 // from the comment.
4196 // mainCtrl.SimulateRestart(t)
4197 // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4198 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
4200 // Delete subscription 2
4201 deleteXapp2Subscription(t, &restSubId2)
4203 //Wait that subs is cleaned
4204 waitSubsCleanup(t, e2SubsId2, 10)
4206 mainCtrl.VerifyCounterValues(t)
4209 //-----------------------------------------------------------------------------
4210 // TestRESTReportSubReqAndSubDelOk
4213 // +-------+ +---------+ +---------+
4214 // | xapp | | submgr | | e2term |
4215 // +-------+ +---------+ +---------+
4218 // |---------------->| |
4220 // | RESTSubResp | |
4221 // |<----------------| |
4224 // | |------------->|
4227 // | |<-------------|
4229 // |<----------------| |
4231 // | |------------->|
4234 // | |<-------------|
4236 // |<----------------| |
4240 // | RESTSubDelReq | |
4241 // |---------------->| |
4244 // | |------------->|
4247 // | |<-------------|
4249 // | RESTSubDelResp| |
4250 // |<----------------| |
4252 //-----------------------------------------------------------------------------
4253 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
4254 CaseBegin("TestRESTReportSubReqAndSubDelOk")
4256 parameterSet := 1 // E2SM-gNB-X2
4257 actionDefinitionPresent := true
4258 actionParamCount := 1
4260 RESTReportSubReqAndSubDelOk(t, subReqCount, parameterSet, actionDefinitionPresent, actionParamCount, testIndex)
4263 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, parameterSet int, actionDefinitionPresent bool, actionParamCount int, testIndex int) {
4264 xapp.Logger.Info("TEST: TestRESTReportSubReqAndSubDelOk with parameter set %v", testIndex)
4267 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4268 restSubId := xappConn1.SendRESTSubsReq(t, params)
4270 var e2SubsId []uint32
4271 for i := 0; i < subReqCount; i++ {
4272 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4273 xappConn1.ExpectRESTNotification(t, restSubId)
4275 e2termConn1.SendSubsResp(t, crereq, cremsg)
4276 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
4277 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
4278 e2SubsId = append(e2SubsId, instanceId)
4279 resp, _ := xapp.Subscription.QuerySubscriptions()
4280 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
4281 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
4282 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
4287 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4289 for i := 0; i < subReqCount; i++ {
4290 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4291 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4294 // Wait that subs is cleaned
4295 for i := 0; i < subReqCount; i++ {
4296 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
4299 xappConn1.TestMsgChanEmpty(t)
4300 e2termConn1.TestMsgChanEmpty(t)
4301 mainCtrl.wait_registry_empty(t, 10)
4305 func TestRESTPolicySubReqAndSubDelOk(t *testing.T) {
4306 CaseBegin("TestRESTPolicySubReqAndSubDelOk")
4309 actionDefinitionPresent := true
4310 policyParamCount := 1
4312 RESTPolicySubReqAndSubDelOk(t, subReqCount, actionDefinitionPresent, policyParamCount, testIndex)
4315 actionDefinitionPresent = false
4316 policyParamCount = 0
4318 RESTPolicySubReqAndSubDelOk(t, subReqCount, actionDefinitionPresent, policyParamCount, testIndex)
4321 func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, actionDefinitionPresent bool, policyParamCount int, testIndex int) {
4322 xapp.Logger.Info("TEST: TestRESTPolicySubReqAndSubDelOk with parameter set %v", testIndex)
4325 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
4326 restSubId := xappConn1.SendRESTSubsReq(t, params)
4327 //params := xappConn1.GetRESTSubsReqPolicyParams1(subReqCount, actionDefinitionPresent, policyParamCount)
4328 //restSubId := xappConn1.SendRESTPolicySubsReq(t, params)
4330 var e2SubsId []uint32
4331 for i := 0; i < subReqCount; i++ {
4332 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4333 xappConn1.ExpectRESTNotification(t, restSubId)
4334 e2termConn1.SendSubsResp(t, crereq, cremsg)
4335 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
4336 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
4337 e2SubsId = append(e2SubsId, instanceId)
4341 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4343 for i := 0; i < subReqCount; i++ {
4344 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4345 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4348 // Wait that subs is cleaned
4349 for i := 0; i < subReqCount; i++ {
4350 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
4352 xappConn1.TestMsgChanEmpty(t)
4353 e2termConn1.TestMsgChanEmpty(t)
4354 mainCtrl.wait_registry_empty(t, 10)
4357 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
4361 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4362 Counter{cSubReqFromXapp, 1},
4363 Counter{cSubReqToE2, 2},
4364 Counter{cSubRespFromE2, 2},
4365 Counter{cSubRespToXapp, 2},
4366 Counter{cSubDelReqFromXapp, 1},
4367 Counter{cSubDelReqToE2, 2},
4368 Counter{cSubDelRespFromE2, 2},
4369 Counter{cSubDelRespToXapp, 1},
4373 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
4374 restSubId := xappConn1.SendRESTSubsReq(t, params)
4375 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4377 assert.Equal(t, len(e2SubsIds), 2)
4380 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4381 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4383 xappConn1.TestMsgChanEmpty(t)
4384 e2termConn1.TestMsgChanEmpty(t)
4385 mainCtrl.wait_registry_empty(t, 10)
4387 mainCtrl.VerifyCounterValues(t)
4389 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
4393 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4394 Counter{cSubReqFromXapp, 1},
4395 Counter{cSubReqToE2, 19},
4396 Counter{cSubRespFromE2, 19},
4397 Counter{cSubRespToXapp, 19},
4398 Counter{cSubDelReqFromXapp, 1},
4399 Counter{cSubDelReqToE2, 19},
4400 Counter{cSubDelRespFromE2, 19},
4401 Counter{cSubDelRespToXapp, 1},
4405 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
4406 restSubId := xappConn1.SendRESTSubsReq(t, params)
4407 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4409 assert.Equal(t, len(e2SubsIds), 19)
4411 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4412 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4414 xappConn1.TestMsgChanEmpty(t)
4415 e2termConn1.TestMsgChanEmpty(t)
4416 mainCtrl.wait_registry_empty(t, 10)
4418 mainCtrl.VerifyCounterValues(t)
4420 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
4424 actionDefinitionPresent := true
4425 actionParamCount := 1
4427 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4428 Counter{cSubReqFromXapp, 1},
4429 Counter{cSubReqToE2, uint64(subReqCount)},
4430 Counter{cSubRespFromE2, uint64(subReqCount)},
4431 Counter{cSubRespToXapp, uint64(subReqCount)},
4432 Counter{cSubDelReqFromXapp, 1},
4433 Counter{cSubDelReqToE2, uint64(subReqCount)},
4434 Counter{cSubDelRespFromE2, uint64(subReqCount)},
4435 Counter{cSubDelRespToXapp, 1},
4439 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4440 restSubId := xappConn1.SendRESTSubsReq(t, params)
4441 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4443 assert.Equal(t, len(e2SubsIds), subReqCount)
4446 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4447 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4449 xappConn1.TestMsgChanEmpty(t)
4450 e2termConn1.TestMsgChanEmpty(t)
4451 mainCtrl.wait_registry_empty(t, 10)
4453 mainCtrl.VerifyCounterValues(t)
4456 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
4460 actionDefinitionPresent := false
4461 actionParamCount := 0
4463 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4464 Counter{cSubReqFromXapp, 1},
4465 Counter{cSubReqToE2, uint64(subReqCount)},
4466 Counter{cSubRespFromE2, uint64(subReqCount)},
4467 Counter{cSubRespToXapp, uint64(subReqCount)},
4468 Counter{cSubDelReqFromXapp, 1},
4469 Counter{cSubDelReqToE2, uint64(subReqCount)},
4470 Counter{cSubDelRespFromE2, uint64(subReqCount)},
4471 Counter{cSubDelRespToXapp, 1},
4475 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4476 restSubId := xappConn1.SendRESTSubsReq(t, params)
4477 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4479 assert.Equal(t, len(e2SubsIds), subReqCount)
4482 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4483 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4485 xappConn1.TestMsgChanEmpty(t)
4486 e2termConn1.TestMsgChanEmpty(t)
4487 mainCtrl.wait_registry_empty(t, 10)
4489 mainCtrl.VerifyCounterValues(t)
4492 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
4496 actionDefinitionPresent := false
4497 actionParamCount := 0
4499 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4500 Counter{cSubReqFromXapp, 1},
4501 Counter{cSubReqToE2, uint64(subReqCount)},
4502 Counter{cSubRespFromE2, uint64(subReqCount)},
4503 Counter{cSubRespToXapp, uint64(subReqCount)},
4504 Counter{cSubDelReqFromXapp, 1},
4505 Counter{cSubDelReqToE2, uint64(subReqCount)},
4506 Counter{cSubDelRespFromE2, uint64(subReqCount)},
4507 Counter{cSubDelRespToXapp, 1},
4511 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4512 restSubId := xappConn1.SendRESTSubsReq(t, params)
4513 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4515 assert.Equal(t, len(e2SubsIds), subReqCount)
4518 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4519 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4521 xappConn1.TestMsgChanEmpty(t)
4522 e2termConn1.TestMsgChanEmpty(t)
4523 mainCtrl.wait_registry_empty(t, 10)
4525 mainCtrl.VerifyCounterValues(t)
4528 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
4529 CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
4531 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4532 Counter{cSubReqFromXapp, 2},
4533 Counter{cSubReqToE2, 2},
4534 Counter{cSubRespFromE2, 2},
4535 Counter{cSubRespToXapp, 2},
4536 Counter{cSubDelReqFromXapp, 2},
4537 Counter{cSubDelReqToE2, 2},
4538 Counter{cSubDelRespFromE2, 2},
4539 Counter{cSubDelRespToXapp, 2},
4543 var params *teststube2ap.RESTSubsReqParams = nil
4546 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4547 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4549 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4552 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4553 params.SetMeid("RAN_NAME_1")
4554 eventTriggerDefinition := "1234"
4555 params.SetSubEventTriggerDefinition(eventTriggerDefinition)
4557 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4558 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4559 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4560 xappConn2.ExpectRESTNotification(t, restSubId2)
4561 e2termConn1.SendSubsResp(t, crereq, cremsg)
4562 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4564 deleteXapp1Subscription(t, &restSubId1)
4565 deleteXapp2Subscription(t, &restSubId2)
4567 waitSubsCleanup(t, e2SubsId1, 10)
4568 waitSubsCleanup(t, e2SubsId2, 10)
4570 mainCtrl.VerifyCounterValues(t)
4574 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
4575 CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
4577 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4578 Counter{cSubReqFromXapp, 2},
4579 Counter{cSubReqToE2, 2},
4580 Counter{cSubRespFromE2, 2},
4581 Counter{cSubRespToXapp, 2},
4582 Counter{cSubDelReqFromXapp, 2},
4583 Counter{cSubDelReqToE2, 2},
4584 Counter{cSubDelRespFromE2, 2},
4585 Counter{cSubDelRespToXapp, 2},
4589 var params *teststube2ap.RESTSubsReqParams = nil
4592 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4593 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4595 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4598 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4599 params.SetMeid("RAN_NAME_1")
4601 actionId := int64(1)
4602 actionType := "report"
4603 actionDefinition := "56781"
4604 subsequestActionType := "continue"
4605 timeToWait := "w10ms"
4606 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
4608 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4609 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4610 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4611 xappConn2.ExpectRESTNotification(t, restSubId2)
4612 e2termConn1.SendSubsResp(t, crereq, cremsg)
4613 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4615 deleteXapp1Subscription(t, &restSubId1)
4616 deleteXapp2Subscription(t, &restSubId2)
4618 waitSubsCleanup(t, e2SubsId1, 10)
4619 waitSubsCleanup(t, e2SubsId2, 10)
4621 mainCtrl.VerifyCounterValues(t)
4625 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
4626 CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
4628 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4629 Counter{cSubReqFromXapp, 2},
4630 Counter{cSubReqToE2, 2},
4631 Counter{cSubRespFromE2, 2},
4632 Counter{cSubRespToXapp, 2},
4633 Counter{cSubDelReqFromXapp, 2},
4634 Counter{cSubDelReqToE2, 2},
4635 Counter{cSubDelRespFromE2, 2},
4636 Counter{cSubDelRespToXapp, 2},
4640 var params *teststube2ap.RESTSubsReqParams = nil
4643 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4644 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4646 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4649 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4650 params.SetMeid("RAN_NAME_1")
4651 params.SetSubActionIDs(int64(2))
4653 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4654 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4655 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4656 xappConn2.ExpectRESTNotification(t, restSubId2)
4657 e2termConn1.SendSubsResp(t, crereq, cremsg)
4658 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4660 deleteXapp1Subscription(t, &restSubId1)
4661 deleteXapp2Subscription(t, &restSubId2)
4663 waitSubsCleanup(t, e2SubsId1, 10)
4664 waitSubsCleanup(t, e2SubsId2, 10)
4666 mainCtrl.VerifyCounterValues(t)
4670 func TestRESTSubReqDiffActionType(t *testing.T) {
4671 CaseBegin("TestRESTSubReqDiffActionType")
4673 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4674 Counter{cSubReqFromXapp, 2},
4675 Counter{cSubReqToE2, 2},
4676 Counter{cSubRespFromE2, 2},
4677 Counter{cSubRespToXapp, 2},
4678 Counter{cSubDelReqFromXapp, 2},
4679 Counter{cSubDelReqToE2, 2},
4680 Counter{cSubDelRespFromE2, 2},
4681 Counter{cSubDelRespToXapp, 2},
4685 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
4688 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4689 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4691 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4694 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4695 params.SetMeid("RAN_NAME_1")
4697 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4698 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4699 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4700 xappConn2.ExpectRESTNotification(t, restSubId2)
4701 e2termConn1.SendSubsResp(t, crereq, cremsg)
4702 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4704 deleteXapp1Subscription(t, &restSubId1)
4705 deleteXapp2Subscription(t, &restSubId2)
4707 waitSubsCleanup(t, e2SubsId1, 10)
4708 waitSubsCleanup(t, e2SubsId2, 10)
4710 mainCtrl.VerifyCounterValues(t)
4714 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
4715 CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
4717 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4718 Counter{cSubReqFromXapp, 2},
4719 Counter{cSubReqToE2, 2},
4720 Counter{cSubRespFromE2, 2},
4721 Counter{cSubRespToXapp, 2},
4722 Counter{cSubDelReqFromXapp, 2},
4723 Counter{cSubDelReqToE2, 2},
4724 Counter{cSubDelRespFromE2, 2},
4725 Counter{cSubDelRespToXapp, 2},
4729 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
4732 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4733 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4735 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4738 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
4739 params.SetMeid("RAN_NAME_1")
4741 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4742 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4743 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4744 xappConn2.ExpectRESTNotification(t, restSubId2)
4745 e2termConn1.SendSubsResp(t, crereq, cremsg)
4746 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4748 deleteXapp1Subscription(t, &restSubId1)
4749 deleteXapp2Subscription(t, &restSubId2)
4751 waitSubsCleanup(t, e2SubsId1, 10)
4752 waitSubsCleanup(t, e2SubsId2, 10)
4754 mainCtrl.VerifyCounterValues(t)
4758 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
4759 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
4761 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4762 Counter{cSubReqFromXapp, 2},
4763 Counter{cSubReqToE2, 2},
4764 Counter{cSubRespFromE2, 2},
4765 Counter{cSubRespToXapp, 2},
4766 Counter{cSubDelReqFromXapp, 2},
4767 Counter{cSubDelReqToE2, 2},
4768 Counter{cSubDelRespFromE2, 2},
4769 Counter{cSubDelRespToXapp, 2},
4773 var params *teststube2ap.RESTSubsReqParams = nil
4776 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4777 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4779 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4782 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4783 params.SetMeid("RAN_NAME_1")
4784 actionDefinition := "5678"
4785 params.SetSubActionDefinition(actionDefinition)
4787 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4788 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4789 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4790 xappConn2.ExpectRESTNotification(t, restSubId2)
4791 e2termConn1.SendSubsResp(t, crereq, cremsg)
4792 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4794 deleteXapp1Subscription(t, &restSubId1)
4795 deleteXapp2Subscription(t, &restSubId2)
4797 waitSubsCleanup(t, e2SubsId1, 10)
4798 waitSubsCleanup(t, e2SubsId2, 10)
4800 mainCtrl.VerifyCounterValues(t)
4804 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
4805 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
4807 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4808 Counter{cSubReqFromXapp, 2},
4809 Counter{cSubReqToE2, 2},
4810 Counter{cSubRespFromE2, 2},
4811 Counter{cSubRespToXapp, 2},
4812 Counter{cSubDelReqFromXapp, 2},
4813 Counter{cSubDelReqToE2, 2},
4814 Counter{cSubDelRespFromE2, 2},
4815 Counter{cSubDelRespToXapp, 2},
4819 var params *teststube2ap.RESTSubsReqParams = nil
4822 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4823 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4825 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4828 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4829 params.SetMeid("RAN_NAME_1")
4830 actionDefinition := "56782"
4831 params.SetSubActionDefinition(actionDefinition)
4833 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4834 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4835 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4836 xappConn2.ExpectRESTNotification(t, restSubId2)
4837 e2termConn1.SendSubsResp(t, crereq, cremsg)
4838 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4840 deleteXapp1Subscription(t, &restSubId1)
4841 deleteXapp2Subscription(t, &restSubId2)
4843 waitSubsCleanup(t, e2SubsId1, 10)
4844 waitSubsCleanup(t, e2SubsId2, 10)
4846 mainCtrl.VerifyCounterValues(t)
4850 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
4851 CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
4853 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4854 Counter{cSubReqFromXapp, 2},
4855 Counter{cSubReqToE2, 2},
4856 Counter{cSubRespFromE2, 2},
4857 Counter{cSubRespToXapp, 2},
4858 Counter{cSubDelReqFromXapp, 2},
4859 Counter{cSubDelReqToE2, 2},
4860 Counter{cSubDelRespFromE2, 2},
4861 Counter{cSubDelRespToXapp, 2},
4865 var params *teststube2ap.RESTSubsReqParams = nil
4868 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4869 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4871 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4874 params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4875 params.SetMeid("RAN_NAME_1")
4876 params.SetTimeToWait("w200ms")
4877 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4878 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4879 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4880 xappConn2.ExpectRESTNotification(t, restSubId2)
4881 e2termConn1.SendSubsResp(t, crereq, cremsg)
4882 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4884 deleteXapp1Subscription(t, &restSubId1)
4885 deleteXapp2Subscription(t, &restSubId2)
4887 waitSubsCleanup(t, e2SubsId1, 10)
4888 waitSubsCleanup(t, e2SubsId2, 10)
4890 mainCtrl.VerifyCounterValues(t)
4894 ////////////////////////////////////////////////////////////////////////////////////
4895 // Services for UT cases
4896 ////////////////////////////////////////////////////////////////////////////////////
4897 const subReqCount int = 1
4898 const parameterSet = 1
4899 const actionDefinitionPresent bool = true
4900 const actionParamCount int = 1
4901 const policyParamCount int = 1
4902 const host string = "localhost"
4904 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
4906 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4908 restSubId := fromXappConn.SendRESTSubsReq(t, params)
4909 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
4911 crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
4912 fromXappConn.ExpectRESTNotification(t, restSubId)
4913 toE2termConn.SendSubsResp(t, crereq1, cremsg1)
4914 e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
4915 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
4917 return restSubId, e2SubsId
4920 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
4922 params := xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4924 params.SetMeid(meid)
4926 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4927 restSubId := xappConn2.SendRESTSubsReq(t, params)
4928 xappConn2.ExpectRESTNotification(t, restSubId)
4929 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
4930 e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
4931 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
4933 return restSubId, e2SubsId
4936 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
4937 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
4938 restSubId := xappConn1.SendRESTSubsReq(t, params)
4939 xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
4941 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4942 xappConn1.ExpectRESTNotification(t, restSubId)
4943 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4944 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4945 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
4947 return restSubId, e2SubsId
4950 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
4951 params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
4952 restSubId := xappConn1.SendRESTSubsReq(t, params)
4954 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4955 fparams1 := &teststube2ap.E2StubSubsFailParams{}
4956 fparams1.Set(crereq1)
4957 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
4959 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4960 xappConn1.ExpectRESTNotification(t, restSubId)
4961 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4962 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4963 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
4965 return restSubId, e2SubsId
4968 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
4969 fromXappConn.SendRESTSubsDelReq(t, restSubId)
4970 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
4971 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
4974 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
4975 xappConn1.SendRESTSubsDelReq(t, restSubId)
4976 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4977 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4980 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
4981 xappConn2.SendRESTSubsDelReq(t, restSubId)
4982 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4983 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4986 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
4987 resp, _ := xapp.Subscription.QuerySubscriptions()
4988 assert.Equal(t, resp[0].SubscriptionID, e2SubsId)
4989 assert.Equal(t, resp[0].Meid, meid)
4990 assert.Equal(t, resp[0].ClientEndpoint, endpoint)
4993 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
4994 //Wait that subs is cleaned
4995 mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
4997 xappConn1.TestMsgChanEmpty(t)
4998 xappConn2.TestMsgChanEmpty(t)
4999 e2termConn1.TestMsgChanEmpty(t)
5000 mainCtrl.wait_registry_empty(t, timeout)
5003 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
5005 var e2SubsId []uint32
5007 for i := 0; i < count; i++ {
5008 xapp.Logger.Info("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
5009 crereq, cremsg := toE2termConn.RecvSubsReq(t)
5010 fromXappConn.ExpectRESTNotification(t, restSubId)
5011 toE2termConn.SendSubsResp(t, crereq, cremsg)
5012 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
5013 e2SubsId = append(e2SubsId, instanceId)
5014 xapp.Logger.Info("TEST: %v", e2SubsId)
5015 xapp.Logger.Info("TEST: %d ===================================== END CRE ============================================", i+1)
5016 <-time.After(100 * time.Millisecond)
5021 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
5023 for i := 0; i < len(e2SubsIds); i++ {
5024 xapp.Logger.Info("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
5025 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
5026 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
5027 <-time.After(1 * time.Second)
5028 xapp.Logger.Info("TEST: %d ===================================== END DEL ============================================", i+1)
5029 <-time.After(100 * time.Millisecond)
5032 // Wait that subs is cleaned
5033 for i := 0; i < len(e2SubsIds); i++ {
5034 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)