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 // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
2263 waiter := rtmgrHttp.AllocNextSleep(50, false)
2264 newSubsId := mainCtrl.get_registry_next_subid(t)
2267 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2268 restSubId := xappConn1.SendRESTSubsReq(t, params)
2269 xappConn1.ExpectRESTNotification(t, restSubId)
2270 waiter.WaitResult(t)
2272 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2273 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
2276 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2278 // Wait that subs is cleaned
2279 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2280 waitSubsCleanup(t, e2SubsId, 10)
2281 mainCtrl.VerifyCounterValues(t)
2284 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
2285 CaseBegin("TestSubReqAndRouteUpdateNok")
2287 //Init counter check
2288 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2289 Counter{cSubReqFromXapp, 2},
2290 Counter{cSubReqToE2, 1},
2291 Counter{cSubRespFromE2, 1},
2292 Counter{cSubRespToXapp, 2},
2293 Counter{cRouteCreateUpdateFail, 1},
2294 Counter{cSubDelReqFromXapp, 1},
2295 Counter{cSubDelReqToE2, 1},
2296 Counter{cSubDelRespFromE2, 1},
2297 Counter{cSubDelRespToXapp, 1},
2300 var params *teststube2ap.RESTSubsReqParams = nil
2303 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2305 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2307 // xapp2 ROUTE creation shall fail with 400 from rtmgr -> submgr
2308 waiter := rtmgrHttp.AllocNextEvent(false)
2309 newSubsId := mainCtrl.get_registry_next_subid(t)
2310 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
2311 params.SetMeid("RAN_NAME_1")
2312 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2313 xapp.Logger.Info("Send REST subscriber request for second subscriber : %v", restSubId2)
2314 xappConn2.ExpectRESTNotification(t, restSubId2)
2315 waiter.WaitResult(t)
2316 // e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) - TOD: missing delete
2317 xappConn2.WaitRESTNotification(t, restSubId2)
2319 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2321 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2323 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2324 //Wait that subs is cleaned
2325 waitSubsCleanup(t, e2SubsId, 10)
2327 mainCtrl.VerifyCounterValues(t)
2330 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
2331 CaseBegin("TestRESTSubDelReqAndRouteDeleteNok")
2333 // Init counter check
2334 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2335 Counter{cSubReqFromXapp, 1},
2336 Counter{cSubReqToE2, 1},
2337 Counter{cSubRespFromE2, 1},
2338 Counter{cSubRespToXapp, 1},
2339 Counter{cSubDelReqFromXapp, 1},
2340 Counter{cRouteDeleteFail, 1},
2341 Counter{cSubDelReqToE2, 1},
2342 Counter{cSubDelRespFromE2, 1},
2343 Counter{cSubDelRespToXapp, 1},
2346 var params *teststube2ap.RESTSubsReqParams = nil
2349 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2351 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2353 waiter := rtmgrHttp.AllocNextEvent(false)
2354 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2355 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2356 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2357 waiter.WaitResult(t)
2359 waitSubsCleanup(t, e2SubsId, 10)
2361 mainCtrl.VerifyCounterValues(t)
2364 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
2365 CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok")
2367 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2368 Counter{cSubReqFromXapp, 2},
2369 Counter{cSubReqToE2, 1},
2370 Counter{cSubRespFromE2, 1},
2371 Counter{cSubRespToXapp, 2},
2372 Counter{cSubDelReqFromXapp, 2},
2373 Counter{cRouteDeleteUpdateFail, 1},
2374 Counter{cSubDelReqToE2, 1},
2375 Counter{cSubDelRespFromE2, 1},
2376 Counter{cSubDelRespToXapp, 2},
2379 var params *teststube2ap.RESTSubsReqParams = nil
2382 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2384 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2385 restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1")
2387 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
2389 //Del1, this shall fail on rtmgr side
2390 waiter := rtmgrHttp.AllocNextEvent(false)
2391 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2392 waiter.WaitResult(t)
2394 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"})
2397 deleteXapp2Subscription(t, &restSubId2)
2399 waitSubsCleanup(t, e2SubsId2, 10)
2401 mainCtrl.VerifyCounterValues(t)
2404 //-----------------------------------------------------------------------------
2405 // TestRESTSubReqRetransmission
2408 // +-------+ +---------+ +---------+
2409 // | xapp | | submgr | | e2term |
2410 // +-------+ +---------+ +---------+
2412 // | RESTSubReq1 | |
2413 // |---------------->| |
2415 // | RESTSubResp | |
2416 // |<----------------| |
2418 // | |------------->|
2420 // | RESTSubReq2 | |
2422 // |---------------->| |
2425 // | |------------->|
2426 // | RESTSubResp2 | |
2427 // |<----------------| |
2429 // | |<-------------|
2431 // |<----------------| |
2433 // | |<-------------|
2435 // |<----------------| |
2437 // | [SUBS DELETE] |
2440 //-----------------------------------------------------------------------------
2442 func TestRESTSubReqRetransmission(t *testing.T) {
2443 CaseBegin("TestRESTSubReqRetransmission")
2445 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2446 Counter{cSubReqFromXapp, 2},
2447 Counter{cSubReqToE2, 2},
2448 Counter{cSubRespFromE2, 2},
2449 Counter{cSubRespToXapp, 2},
2450 Counter{cSubDelReqFromXapp, 2},
2451 Counter{cSubDelReqToE2, 2},
2452 Counter{cSubDelRespFromE2, 2},
2453 Counter{cSubDelRespToXapp, 2},
2455 // Retry/duplicate will get the same way as the first request. Submgr cannot detect duplicate RESTRequests
2456 // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
2457 // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
2460 const subReqCount int = 1
2462 // In order to force both XAPP's to create their own subscriptions, force rtmgr to block a while so that 2nd create
2463 // gets into execution before the rtmgrg responds for the first one.
2464 waiter := rtmgrHttp.AllocNextSleep(10, true)
2465 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2466 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
2467 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2469 waiter.WaitResult(t)
2471 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
2473 // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
2474 // the order is not significant he6re.
2475 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2476 e2termConn1.SendSubsResp(t, crereq, cremsg)
2477 crereq, cremsg = e2termConn1.RecvSubsReq(t)
2478 e2termConn1.SendSubsResp(t, crereq, cremsg)
2480 e2SubsIdA := <-xappConn1.ListedRESTNotifications
2481 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
2482 e2SubsIdB := <-xappConn1.ListedRESTNotifications
2483 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
2486 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
2487 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2488 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2491 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
2492 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2493 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2495 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
2497 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
2499 mainCtrl.VerifyCounterValues(t)
2502 func TestRESTSubDelReqRetransmission(t *testing.T) {
2503 CaseBegin("TestRESTSubDelReqRetransmission")
2505 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2506 Counter{cSubReqFromXapp, 1},
2507 Counter{cSubReqToE2, 1},
2508 Counter{cSubRespFromE2, 1},
2509 Counter{cSubRespToXapp, 1},
2510 Counter{cSubDelReqFromXapp, 2},
2511 Counter{cSubDelReqToE2, 1},
2512 Counter{cSubDelRespFromE2, 1},
2513 Counter{cSubDelRespToXapp, 1},
2516 var params *teststube2ap.RESTSubsReqParams = nil
2519 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2521 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2524 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2525 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2527 seqBef := mainCtrl.get_msgcounter(t)
2528 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2529 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
2531 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2533 waitSubsCleanup(t, e2SubsId, 10)
2535 mainCtrl.VerifyCounterValues(t)
2538 //-----------------------------------------------------------------------------
2539 // TestRESTSubReqDelReq
2542 // +-------+ +---------+ +---------+
2543 // | xapp | | submgr | | e2term |
2544 // +-------+ +---------+ +---------+
2547 // |---------------->| |
2549 // | RESTSubResp | |
2550 // |<----------------| |
2552 // | |------------->|
2553 // | RESTSubDelReq | |
2554 // |---------------->| |
2555 // | RESTSubDelResp | |
2557 // |<----------------| |
2559 // | |<-------------|
2561 // |<----------------| |
2563 // | [SUBS DELETE] |
2566 //-----------------------------------------------------------------------------
2567 func TestRESTSubReqDelReq(t *testing.T) {
2568 CaseBegin("TestRESTSubReqDelReq")
2570 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2571 Counter{cSubReqFromXapp, 1},
2572 Counter{cSubReqToE2, 1},
2573 Counter{cSubRespFromE2, 1},
2574 Counter{cSubRespToXapp, 1},
2575 Counter{cSubDelReqFromXapp, 2},
2576 Counter{cSubDelReqToE2, 1},
2577 Counter{cSubDelRespFromE2, 1},
2578 Counter{cSubDelRespToXapp, 1},
2581 const subReqCount int = 1
2584 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2585 restSubId := xappConn1.SendRESTSubsReq(t, params)
2587 // Del. This will fail as processing of the subscription
2588 // is still ongoing in submgr. Deletion is not allowed before
2589 // subscription creation has been completed.
2590 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2591 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2592 xappConn1.ExpectRESTNotification(t, restSubId)
2593 e2termConn1.SendSubsResp(t, crereq, cremsg)
2594 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2597 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2599 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2600 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2602 // Wait that subs is cleaned
2603 waitSubsCleanup(t, e2SubsId, 10)
2604 mainCtrl.VerifyCounterValues(t)
2608 func TestRESTSubDelReqCollision(t *testing.T) {
2609 CaseBegin("TestRESTSubDelReqCollision - not relevant for REST API")
2612 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
2613 CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel")
2615 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2616 Counter{cSubReqFromXapp, 2},
2617 Counter{cSubReqToE2, 2},
2618 Counter{cSubRespFromE2, 2},
2619 Counter{cSubRespToXapp, 2},
2620 Counter{cSubDelReqFromXapp, 2},
2621 Counter{cSubDelReqToE2, 2},
2622 Counter{cSubDelRespFromE2, 2},
2623 Counter{cSubDelRespToXapp, 2},
2627 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2628 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
2629 xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
2632 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
2633 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2634 xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
2636 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2637 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
2639 //XappConn1 receives both of the responses
2640 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
2643 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2645 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
2647 e2SubsIdA := <-xappConn1.ListedRESTNotifications
2648 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
2649 e2SubsIdB := <-xappConn1.ListedRESTNotifications
2650 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
2653 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
2655 deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
2657 //Wait that subs is cleaned
2658 mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
2659 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
2661 mainCtrl.VerifyCounterValues(t)
2665 func TestRESTSameSubsDiffRan(t *testing.T) {
2666 CaseBegin("TestRESTSameSubsDiffRan")
2668 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2669 Counter{cSubReqFromXapp, 2},
2670 Counter{cSubReqToE2, 2},
2671 Counter{cSubRespFromE2, 2},
2672 Counter{cSubRespToXapp, 2},
2673 Counter{cSubDelReqFromXapp, 2},
2674 Counter{cSubDelReqToE2, 2},
2675 Counter{cSubDelRespFromE2, 2},
2676 Counter{cSubDelRespToXapp, 2},
2679 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2680 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
2681 xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
2683 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
2684 params.SetMeid("RAN_NAME_2")
2685 restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
2686 xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
2689 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
2691 deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
2693 //Wait that subs is cleaned
2694 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
2695 waitSubsCleanup(t, e2SubsId2, 10)
2697 mainCtrl.VerifyCounterValues(t)
2701 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
2702 CaseBegin("TestRESTSubReqRetryInSubmgr start")
2704 // Init counter check
2705 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2706 Counter{cSubReqFromXapp, 1},
2707 Counter{cSubReqToE2, 1},
2708 Counter{cSubReReqToE2, 1},
2709 Counter{cSubRespFromE2, 1},
2710 Counter{cSubRespToXapp, 1},
2711 Counter{cSubDelReqFromXapp, 1},
2712 Counter{cSubDelReqToE2, 1},
2713 Counter{cSubDelRespFromE2, 1},
2714 Counter{cSubDelRespToXapp, 1},
2717 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2718 restSubId := xappConn1.SendRESTSubsReq(t, params)
2720 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
2722 // Catch the first message and ignore it
2723 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2724 xapp.Logger.Info("Ignore REST subscriber request for subscriber : %v", restSubId)
2726 // The second request is being handled normally
2727 crereq, cremsg = e2termConn1.RecvSubsReq(t)
2728 xappConn1.ExpectRESTNotification(t, restSubId)
2729 e2termConn1.SendSubsResp(t, crereq, cremsg)
2730 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2732 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2734 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2736 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2737 //Wait that subs is cleaned
2738 waitSubsCleanup(t, e2SubsId, 10)
2740 mainCtrl.VerifyCounterValues(t)
2744 //-----------------------------------------------------------------------------
2745 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
2748 // +-------+ +---------+ +---------+
2749 // | xapp | | submgr | | e2term |
2750 // +-------+ +---------+ +---------+
2753 // |---------------->| |
2755 // | RESTSubResp | |
2756 // |<----------------| |
2758 // | |------------->|
2762 // | |------------->|
2765 // | |------------->|
2769 // | |------------->|
2773 // | |<-------------|
2776 // |<----------------| |
2778 // | [SUBS DELETE] |
2781 //-----------------------------------------------------------------------------
2782 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
2783 CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
2785 // Init counter check
2786 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2787 Counter{cSubReqFromXapp, 1},
2788 Counter{cSubReqToE2, 1},
2789 Counter{cSubReReqToE2, 1},
2790 Counter{cSubReqTimerExpiry, 2},
2791 Counter{cSubDelReqToE2, 1},
2792 Counter{cSubDelRespFromE2, 1},
2795 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2796 restSubId := xappConn1.SendRESTSubsReq(t, params)
2797 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
2799 e2termConn1.RecvSubsReq(t)
2800 xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
2802 e2termConn1.RecvSubsReq(t)
2803 xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
2805 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2806 xappConn1.ExpectRESTNotification(t, restSubId)
2807 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2808 // e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) - TODO: Should we delete this?
2809 xappConn1.WaitRESTNotification(t, restSubId)
2811 // Wait that subs is cleaned
2812 waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
2814 mainCtrl.VerifyCounterValues(t)
2817 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
2818 CaseBegin("TestREST2eTermNotRespondingToSubReq start")
2820 // Init counter check
2821 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2822 Counter{cSubReqFromXapp, 1},
2823 Counter{cSubReqToE2, 1},
2824 Counter{cSubReReqToE2, 1},
2825 Counter{cSubReqTimerExpiry, 2},
2826 Counter{cSubDelReqToE2, 1},
2827 Counter{cSubDelReqTimerExpiry, 2},
2830 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2831 restSubId := xappConn1.SendRESTSubsReq(t, params)
2832 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
2834 e2termConn1.RecvSubsReq(t)
2835 xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
2837 e2termConn1.RecvSubsReq(t)
2838 xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
2840 e2termConn1.RecvSubsDelReq(t)
2841 xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
2843 xappConn1.ExpectRESTNotification(t, restSubId)
2844 e2termConn1.RecvSubsDelReq(t)
2845 xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
2847 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2849 waitSubsCleanup(t, e2SubsId, 10)
2851 mainCtrl.VerifyCounterValues(t)
2855 //-----------------------------------------------------------------------------
2856 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
2859 // +-------+ +---------+ +---------+
2860 // | xapp | | submgr | | e2term |
2861 // +-------+ +---------+ +---------+
2864 // |---------------->| |
2866 // | RESTSubResp | |
2867 // |<----------------| |
2869 // | |------------->|
2873 // | |------------->|
2876 // | |------------->|
2880 // | |------------->|
2884 // | |<-------------|
2887 // |<----------------| |
2889 // | [SUBS DELETE] |
2892 //-----------------------------------------------------------------------------
2893 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
2894 CaseBegin("TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr start")
2896 // Init counter check
2897 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2898 Counter{cSubReqFromXapp, 1},
2899 Counter{cSubReqToE2, 1},
2900 Counter{cSubReReqToE2, 1},
2901 Counter{cSubReqTimerExpiry, 2},
2902 Counter{cSubDelReqToE2, 1},
2903 Counter{cSubDelReReqToE2, 1},
2904 Counter{cSubDelReqTimerExpiry, 2},
2907 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2908 restSubId := xappConn1.SendRESTSubsReq(t, params)
2909 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
2911 e2termConn1.RecvSubsReq(t)
2912 xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
2914 e2termConn1.RecvSubsReq(t)
2915 xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
2917 e2termConn1.RecvSubsDelReq(t)
2918 xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
2920 xappConn1.ExpectRESTNotification(t, restSubId)
2921 e2termConn1.RecvSubsDelReq(t)
2922 xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
2924 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2926 waitSubsCleanup(t, e2SubsId, 10)
2928 mainCtrl.VerifyCounterValues(t)
2931 //-----------------------------------------------------------------------------
2932 // TestRESTSubReqSubFailRespInSubmgr
2935 // +-------+ +---------+ +---------+
2936 // | xapp | | submgr | | e2term |
2937 // +-------+ +---------+ +---------+
2940 // |---------------->| |
2942 // | RESTSubResp | |
2943 // |<----------------| |
2945 // | |------------->|
2948 // | |<-------------|
2951 // | |------------->|
2954 // | |<-------------|
2958 // |<----------------| |
2960 // | [SUBS DELETE] |
2963 //-----------------------------------------------------------------------------
2964 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
2965 CaseBegin("TestRESTSubReqSubFailRespInSubmgr")
2967 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2968 Counter{cSubReqFromXapp, 1},
2969 Counter{cSubReqToE2, 1},
2970 Counter{cSubFailFromE2, 1},
2971 Counter{cSubRespToXapp, 1},
2972 Counter{cSubDelReqFromXapp, 1},
2975 const subReqCount int = 1
2977 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2978 restSubId := xappConn1.SendRESTSubsReq(t, params)
2980 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2981 fparams1 := &teststube2ap.E2StubSubsFailParams{}
2982 fparams1.Set(crereq1)
2983 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
2985 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2986 xappConn1.ExpectRESTNotification(t, restSubId)
2987 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2988 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2989 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
2991 // REST subscription sill there to be deleted
2992 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2994 // Wait that subs is cleaned
2995 waitSubsCleanup(t, e2SubsId, 10)
2997 mainCtrl.VerifyCounterValues(t)
3001 //-----------------------------------------------------------------------------
3002 // TestRESTSubDelReqRetryInSubmgr
3005 // +-------+ +---------+ +---------+
3006 // | xapp | | submgr | | e2term |
3007 // +-------+ +---------+ +---------+
3009 // | [SUBS CREATE] |
3012 // | RESTSubDelReq | |
3013 // |---------------->| |
3015 // | RESTSubDelResp | |
3016 // |<----------------| |
3018 // | |------------->|
3021 // | |------------->|
3024 // | |<-------------|
3027 //-----------------------------------------------------------------------------
3028 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
3029 CaseBegin("TestRESTSubDelReqRetryInSubmgr")
3031 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3032 Counter{cSubReqFromXapp, 1},
3033 Counter{cSubReqToE2, 1},
3034 Counter{cSubRespFromE2, 1},
3035 Counter{cSubRespToXapp, 1},
3036 Counter{cSubDelReqFromXapp, 1},
3037 Counter{cSubDelReqToE2, 1},
3038 Counter{cSubDelReReqToE2, 1},
3039 Counter{cSubDelRespFromE2, 1},
3040 Counter{cSubDelRespToXapp, 1},
3043 var params *teststube2ap.RESTSubsReqParams = nil
3044 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3047 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3049 // E2t: Receive 1st SubsDelReq
3050 e2termConn1.RecvSubsDelReq(t)
3052 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
3053 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3054 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3056 //Wait that subs is cleaned
3057 waitSubsCleanup(t, e2SubsId, 10)
3059 mainCtrl.VerifyCounterValues(t)
3062 //-----------------------------------------------------------------------------
3063 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
3066 // +-------+ +---------+ +---------+
3067 // | xapp | | submgr | | e2term |
3068 // +-------+ +---------+ +---------+
3070 // | [SUBS CREATE] |
3073 // | RESTSubDelReq | |
3074 // |---------------->| |
3076 // | RESTSubDelResp | |
3077 // |<----------------| |
3079 // | |------------->|
3082 // | |------------->|
3086 //-----------------------------------------------------------------------------
3087 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
3088 CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr")
3090 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3091 Counter{cSubReqFromXapp, 1},
3092 Counter{cSubReqToE2, 1},
3093 Counter{cSubRespFromE2, 1},
3094 Counter{cSubRespToXapp, 1},
3095 Counter{cSubDelReqFromXapp, 1},
3096 Counter{cSubDelReqToE2, 1},
3097 Counter{cSubDelReReqToE2, 1},
3098 Counter{cSubDelRespFromE2, 1},
3099 Counter{cSubDelRespToXapp, 1},
3103 var params *teststube2ap.RESTSubsReqParams = nil
3104 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3107 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3109 // E2t: Receive 1st SubsDelReq
3110 e2termConn1.RecvSubsDelReq(t)
3112 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
3113 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3114 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3116 //Wait that subs is cleaned
3117 waitSubsCleanup(t, e2SubsId, 10)
3119 mainCtrl.VerifyCounterValues(t)
3122 //-----------------------------------------------------------------------------
3123 // TestRESTSubDelReqSubDelFailRespInSubmgr
3126 // +-------+ +---------+ +---------+
3127 // | xapp | | submgr | | e2term |
3128 // +-------+ +---------+ +---------+
3130 // | [SUBS CREATE] |
3133 // | RESTSubDelReq | |
3134 // |---------------->| |
3136 // | RESTSubDelResp | |
3137 // |<----------------| |
3139 // | |------------->|
3142 // | |<-------------|
3145 //-----------------------------------------------------------------------------
3146 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
3147 CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr")
3149 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3150 Counter{cSubReqFromXapp, 1},
3151 Counter{cSubReqToE2, 1},
3152 Counter{cSubRespFromE2, 1},
3153 Counter{cSubRespToXapp, 1},
3154 Counter{cSubDelReqFromXapp, 1},
3155 Counter{cSubDelReqToE2, 1},
3156 Counter{cSubDelFailFromE2, 1},
3157 Counter{cSubDelRespToXapp, 1},
3161 var params *teststube2ap.RESTSubsReqParams = nil
3162 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3165 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3167 // E2t: Send receive SubsDelReq and send SubsDelFail
3168 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3169 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
3171 //Wait that subs is cleaned
3172 waitSubsCleanup(t, e2SubsId, 10)
3174 mainCtrl.VerifyCounterValues(t)
3177 //-----------------------------------------------------------------------------
3178 // TestRESTSubReqAndSubDelOkSameAction
3181 // +-------+ +-------+ +---------+ +---------+
3182 // | xapp2 | | xapp1 | | submgr | | e2term |
3183 // +-------+ +-------+ +---------+ +---------+
3185 // | | RESTSubReq1 | |
3186 // | |---------------->| |
3188 // | | RESTSubResp1 | |
3189 // | |<----------------| |
3192 // | | |------------->|
3194 // | | |<-------------|
3195 // | | RESTNotif1 | |
3196 // | |<----------------| |
3198 // | RESTSubReq2 | |
3199 // |------------------------------>| |
3201 // | RESTSubResp2 | |
3202 // |<------------------------------| |
3204 // | | RESTNotif2 | |
3205 // |<------------------------------| |
3207 // | | RESTSubDelReq1 | |
3208 // | |---------------->| |
3210 // | | RESTSubDelResp1 | |
3211 // | |<----------------| |
3213 // | RESTSubDelReq2 | |
3214 // |------------------------------>| |
3216 // | RESTSubDelResp2 | |
3217 // |<------------------------------| |
3219 // | | | SubDelReq2 |
3220 // | | |------------->|
3222 // | | | SubDelResp2 |
3223 // | | |<-------------|
3226 //-----------------------------------------------------------------------------
3227 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
3228 CaseBegin("TestRESTSubReqAndSubDelOkSameAction")
3230 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3231 Counter{cSubReqFromXapp, 2},
3232 Counter{cSubReqToE2, 1},
3233 Counter{cSubRespFromE2, 1},
3234 Counter{cSubRespToXapp, 2},
3235 Counter{cMergedSubscriptions, 1},
3236 Counter{cUnmergedSubscriptions, 1},
3237 Counter{cSubDelReqFromXapp, 2},
3238 Counter{cSubDelReqToE2, 1},
3239 Counter{cSubDelRespFromE2, 1},
3240 Counter{cSubDelRespToXapp, 2},
3244 var params *teststube2ap.RESTSubsReqParams = nil
3247 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3248 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
3251 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3252 params.SetMeid("RAN_NAME_1")
3254 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
3255 xappConn2.WaitRESTNotificationForAnySubscriptionId(t)
3256 waiter := rtmgrHttp.AllocNextSleep(10, true)
3257 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3258 waiter.WaitResult(t)
3259 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
3260 e2SubsId2 := <-xappConn2.RESTNotification
3261 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
3263 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
3266 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3269 deleteXapp2Subscription(t, &restSubId2)
3271 //Wait that subs is cleaned
3272 waitSubsCleanup(t, e2SubsId2, 10)
3274 mainCtrl.VerifyCounterValues(t)
3277 //-----------------------------------------------------------------------------
3278 // TestSubReqAndSubDelOkSameActionParallel
3281 // +-------+ +-------+ +---------+ +---------+
3282 // | xapp2 | | xapp1 | | submgr | | e2term |
3283 // +-------+ +-------+ +---------+ +---------+
3288 // | |------------->| |
3291 // | | |------------->|
3293 // |--------------------------->| |
3295 // | | |<-------------|
3297 // | |<-------------| |
3299 // | | |------------->|
3302 // | | |<-------------|
3304 // |<---------------------------| |
3306 // | | SubDelReq 1 | |
3307 // | |------------->| |
3309 // | | SubDelResp 1 | |
3310 // | |<-------------| |
3312 // | SubDelReq 2 | |
3313 // |--------------------------->| |
3315 // | | | SubDelReq 2 |
3316 // | | |------------->|
3318 // | | | SubDelReq 2 |
3319 // | | |------------->|
3321 // | SubDelResp 2 | |
3322 // |<---------------------------| |
3324 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
3325 CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel")
3327 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3328 Counter{cSubReqFromXapp, 2},
3329 Counter{cSubReqToE2, 2},
3330 Counter{cSubRespFromE2, 2},
3331 Counter{cSubRespToXapp, 2},
3332 Counter{cSubDelReqFromXapp, 2},
3333 Counter{cSubDelReqToE2, 2},
3334 Counter{cSubDelRespFromE2, 2},
3335 Counter{cSubDelRespToXapp, 2},
3338 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3339 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3340 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3342 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
3343 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
3345 xappConn1.ExpectRESTNotification(t, restSubId1)
3346 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3347 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
3349 xappConn2.ExpectRESTNotification(t, restSubId2)
3350 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3351 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3352 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
3355 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3356 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3357 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3358 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3361 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
3362 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
3363 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
3365 waitSubsCleanup(t, e2SubsId2, 10)
3367 mainCtrl.VerifyCounterValues(t)
3370 //-----------------------------------------------------------------------------
3371 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
3374 // +-------+ +-------+ +---------+ +---------+
3375 // | xapp2 | | xapp1 | | submgr | | e2term |
3376 // +-------+ +-------+ +---------+ +---------+
3380 // | | RESTSubReq1 | |
3381 // | |---------------->| |
3383 // | | RESTSubResp1 | |
3384 // | |<----------------| |
3386 // | | |------------->|
3387 // | RESTSubReq2 | |
3388 // |------------------------------>| |
3390 // | RESTSubDelResp2 | |
3391 // |<------------------------------| |
3393 // | | |------------->|
3396 // | | | SubDelReq |
3397 // | | |------------->|
3399 // | | | SubDelResp |
3400 // | | |<-------------|
3401 // | | RESTNotif1 | |
3402 // | | unsuccess | |
3403 // | |<----------------| |
3405 // | | unsuccess | |
3406 // |<------------------------------| |
3408 // | | RESTSubDelReq1 | |
3409 // | |---------------->| |
3411 // | | RESTSubDelResp1 | |
3412 // | |<----------------| |
3414 // | RESTSubDelReq2 | |
3415 // |------------------------------>| |
3417 // | RESTSubDelResp2 | |
3418 // |<------------------------------| |
3420 //-----------------------------------------------------------------------------
3421 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
3422 CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
3424 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3425 Counter{cSubReqFromXapp, 2},
3426 Counter{cSubReqToE2, 1},
3427 Counter{cSubRespToXapp, 2},
3428 Counter{cSubDelReqFromXapp, 2},
3429 Counter{cSubDelReqToE2, 1},
3430 Counter{cSubDelRespFromE2, 1},
3431 Counter{cSubDelRespToXapp, 2},
3434 const subReqCount int = 1
3437 params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3438 restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
3439 crereq1, _ := e2termConn1.RecvSubsReq(t)
3442 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
3443 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
3444 params2.SetMeid("RAN_NAME_1")
3445 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
3446 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
3448 //Req1 (retransmitted)
3449 e2termConn1.RecvSubsReq(t)
3451 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3453 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3454 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3456 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3457 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3458 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3459 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3462 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3465 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
3467 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
3469 //Wait that subs is cleaned
3470 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
3472 mainCtrl.VerifyCounterValues(t)
3475 //-----------------------------------------------------------------------------
3476 // TestRESTSubReqAndSubDelNokSameActionParallel
3479 // +-------+ +-------+ +---------+ +---------+
3480 // | xapp2 | | xapp1 | | submgr | | e2term |
3481 // +-------+ +-------+ +---------+ +---------+
3485 // | | RESTSubReq1 | |
3486 // | |---------------->| |
3488 // | | RESTSubResp1 | |
3489 // | |<----------------| |
3491 // | | |------------->|
3492 // | RESTSubReq2 | |
3493 // |------------------------------>| |
3495 // | RESTSubDelResp2 | |
3496 // |<------------------------------| |
3498 // | | |<-------------|
3500 // | | RESTNotif1 | |
3501 // | | unsuccess | |
3502 // | |<----------------| |
3504 // | | unsuccess | |
3505 // |<------------------------------| |
3506 // | | | SubDelReq |
3507 // | | |------------->|
3508 // | | | SubDelResp |
3509 // | | |<-------------|
3511 // | | RESTSubDelReq1 | |
3512 // | |---------------->| |
3514 // | | RESTSubDelResp1 | |
3515 // | |<----------------| |
3517 // | RESTSubDelReq2 | |
3518 // |------------------------------>| |
3520 // | RESTSubDelResp2 | |
3521 // |<------------------------------| |
3523 //-----------------------------------------------------------------------------
3524 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
3525 CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
3527 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3528 Counter{cSubReqFromXapp, 2},
3529 Counter{cSubReqToE2, 1},
3530 Counter{cSubFailFromE2, 1},
3531 Counter{cSubRespToXapp, 2},
3532 Counter{cSubDelReqFromXapp, 2},
3533 Counter{cSubDelReqToE2, 1},
3534 Counter{cSubDelRespFromE2, 1},
3535 Counter{cSubDelRespToXapp, 2},
3538 const subReqCount int = 1
3541 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3542 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3543 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3546 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
3547 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
3548 params2.SetMeid("RAN_NAME_1")
3549 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
3550 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
3552 // E2t: send SubsFail (first)
3553 fparams1 := &teststube2ap.E2StubSubsFailParams{}
3554 fparams1.Set(crereq1)
3555 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3557 // E2t: internal delete
3558 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3559 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3560 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3562 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3563 xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3564 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3565 xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3568 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3571 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
3573 //Wait that subs is cleaned
3574 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
3575 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
3577 mainCtrl.VerifyCounterValues(t)
3580 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
3581 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
3583 // Init counter check
3584 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3585 Counter{cSubReqFromXapp, 1},
3586 Counter{cSubReqToE2, 1},
3587 Counter{cSubRespFromE2, 1},
3588 Counter{cSubRespToXapp, 1},
3589 Counter{cSubDelReqFromXapp, 1},
3590 Counter{cSubDelReqToE2, 1},
3591 Counter{cSubDelRespFromE2, 1},
3592 Counter{cSubDelRespToXapp, 1},
3595 const subReqCount int = 1
3597 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
3598 restSubId := xappConn1.SendRESTSubsReq(t, params)
3599 xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
3601 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3602 xappConn1.ExpectRESTNotification(t, restSubId)
3603 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3604 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3605 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
3607 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3608 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3609 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3611 // Wait that subs is cleaned
3612 waitSubsCleanup(t, e2SubsId, 10)
3613 mainCtrl.VerifyCounterValues(t)
3616 //-----------------------------------------------------------------------------
3617 // TestRESTSubReqPolicyChangeAndSubDelOk
3620 // +-------+ +---------+ +---------+
3621 // | xapp | | submgr | | e2term |
3622 // +-------+ +---------+ +---------+
3625 // |---------------->| |
3627 // | RESTSubResp | |
3628 // |<----------------| |
3630 // | |------------->|
3633 // | |<-------------|
3636 // |<----------------| |
3639 // |---------------->| |
3641 // | RESTSubResp | |
3642 // |<----------------| |
3644 // | |------------->|
3647 // | |<-------------|
3650 // |<----------------| |
3652 // | RESTSubDelReq | |
3653 // |---------------->| |
3656 // | |------------->|
3659 // | |<-------------|
3661 // | RESTSubDelResp | |
3662 // |<----------------| |
3664 //-----------------------------------------------------------------------------
3665 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
3666 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
3668 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3669 Counter{cSubReqFromXapp, 2},
3670 Counter{cSubReqToE2, 2},
3671 Counter{cSubRespFromE2, 2},
3672 Counter{cSubRespToXapp, 2},
3673 Counter{cSubDelReqFromXapp, 1},
3674 Counter{cSubDelReqToE2, 1},
3675 Counter{cSubDelRespFromE2, 1},
3676 Counter{cSubDelRespToXapp, 1},
3679 const subReqCount int = 1
3682 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
3683 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3686 instanceId := int64(e2SubsId)
3687 // GetRESTSubsReqPolicyParams sets some coutners on tc side.
3688 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
3689 params.SubsReqParams.SubscriptionDetails[0].InstanceID = &instanceId
3690 params.SetTimeToWait("w200ms")
3691 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
3694 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3696 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3697 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3699 // Wait that subs is cleaned
3700 waitSubsCleanup(t, e2SubsId, 10)
3701 mainCtrl.VerifyCounterValues(t)
3704 //-----------------------------------------------------------------------------
3705 // TestRESTSubReqAndSubDelOkTwoE2termParallel
3708 // +-------+ +---------+ +---------+ +---------+
3709 // | xapp | | submgr | | e2term1 | | e2term2 |
3710 // +-------+ +---------+ +---------+ +---------+
3714 // | RESTSubReq1 | | |
3715 // |---------------->| | |
3717 // | RESTSubResp1 | | |
3718 // |<----------------| | |
3720 // | |------------->| |
3722 // | RESTSubReq2 | | |
3723 // |---------------->| | |
3725 // | RESTSubResp2 | | |
3726 // |<----------------| | |
3728 // | |---------------------------->|
3731 // | |<-------------| |
3732 // | RESTNotif1 | | |
3733 // |<----------------| | |
3735 // | |<----------------------------|
3736 // | RESTNotif2 | | |
3737 // |<----------------| | |
3739 // | [SUBS 1 DELETE] | |
3741 // | [SUBS 2 DELETE] | |
3744 //-----------------------------------------------------------------------------
3745 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
3746 CaseBegin("TestRESTSubReqAndSubDelOkTwoE2termParallel")
3748 // Init counter check
3749 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3750 Counter{cSubReqFromXapp, 2},
3751 Counter{cSubReqToE2, 2},
3752 Counter{cSubRespFromE2, 2},
3753 Counter{cSubRespToXapp, 2},
3754 Counter{cSubDelReqFromXapp, 2},
3755 Counter{cSubDelReqToE2, 2},
3756 Counter{cSubDelRespFromE2, 2},
3757 Counter{cSubDelRespToXapp, 2},
3760 const subReqCount int = 1
3763 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3764 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3765 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3768 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3769 params.SetMeid("RAN_NAME_11")
3770 // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
3771 // would not work as notification would not be received
3772 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3773 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
3776 xappConn1.ExpectRESTNotification(t, restSubId1)
3777 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3778 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
3779 xapp.Logger.Info("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
3782 xappConn2.ExpectRESTNotification(t, restSubId2)
3783 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
3784 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
3785 xapp.Logger.Info("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
3788 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3789 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3790 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3792 // Wait that subs is cleaned
3793 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3796 xappConn1.SendRESTSubsDelReq(t, &restSubId2)
3797 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
3798 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
3800 // Wait that subs is cleaned
3801 waitSubsCleanup(t, e2SubsId2, 10)
3803 mainCtrl.VerifyCounterValues(t)
3806 //-----------------------------------------------------------------------------
3807 // TestRESTSubReqAsn1EncodeFail
3809 // In this case submgr send RICSubscriptionDeleteRequest after encode failure which should not happen!
3811 // +-------+ +---------+ +---------+
3812 // | xapp | | submgr | | e2term |
3813 // +-------+ +---------+ +---------+
3816 // |---------------->| |
3818 // | RESTSubResp | |
3819 // |<----------------| |
3820 // | RESTSubDelReq | |
3821 // |---------------->| |
3822 // | RESTSubDelResp | |
3824 // |<----------------| |
3827 //-----------------------------------------------------------------------------
3828 func TestRESTSubReqAsn1EncodeFail(t *testing.T) {
3829 CaseBegin("TestRESTSubReqAsn1EncodeFail")
3831 xapp.Logger.Info("Xapp-frame, v0.8.1 sufficient REST API validation")
3835 //-----------------------------------------------------------------------------
3836 // TestRESTSubReqInsertAndSubDelOk
3839 // +-------+ +---------+ +---------+
3840 // | xapp | | submgr | | e2term |
3841 // +-------+ +---------+ +---------+
3844 // |---------------->| |
3846 // | RESTSubResp | |
3847 // |<----------------| |
3850 // | |------------->|
3853 // | |<-------------|
3855 // |<----------------| |
3858 // | RESTSubDelReq | |
3859 // |---------------->| |
3862 // | |------------->|
3865 // | |<-------------|
3867 // | RESTSubDelResp| |
3868 // |<----------------| |
3870 //-----------------------------------------------------------------------------
3871 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
3872 CaseBegin("TestRESTInsertSubReqAndSubDelOk")
3874 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3875 Counter{cSubReqFromXapp, 1},
3876 Counter{cSubReqToE2, 1},
3877 Counter{cSubRespFromE2, 1},
3878 Counter{cSubRespToXapp, 1},
3879 Counter{cSubDelReqFromXapp, 1},
3880 Counter{cSubDelReqToE2, 1},
3881 Counter{cSubDelRespFromE2, 1},
3882 Counter{cSubDelRespToXapp, 1},
3885 const subReqCount int = 1
3887 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3888 params.SetSubActionTypes("insert")
3891 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3894 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3896 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3897 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3899 // Wait that subs is cleaned
3900 waitSubsCleanup(t, e2SubsId, 10)
3901 mainCtrl.VerifyCounterValues(t)
3904 //-----------------------------------------------------------------------------
3905 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
3908 // +-------+ +---------+ +---------+
3909 // | xapp | | submgr | | e2term |
3910 // +-------+ +---------+ +---------+
3913 // |------------->| |
3916 // | |------------->|
3921 // | Submgr restart |
3925 // | |------------->|
3928 // | |<-------------|
3931 //-----------------------------------------------------------------------------
3932 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
3933 CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle")
3935 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3936 Counter{cSubReqFromXapp, 1},
3937 Counter{cSubReqToE2, 1},
3938 Counter{cSubDelReqFromXapp, 1},
3939 Counter{cSubDelReqToE2, 1},
3940 Counter{cSubDelRespFromE2, 1},
3943 const subReqCount int = 1
3945 // Remove possible existing subscription
3946 mainCtrl.removeExistingSubscriptions(t)
3948 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3951 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
3952 restSubId := xappConn1.SendRESTSubsReq(t, params)
3953 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
3955 e2termConn1.RecvSubsReq(t)
3957 mainCtrl.SetResetTestFlag(t, false)
3959 mainCtrl.SimulateRestart(t)
3960 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
3963 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3964 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3966 xappConn1.TestMsgChanEmpty(t)
3967 xappConn2.TestMsgChanEmpty(t)
3968 e2termConn1.TestMsgChanEmpty(t)
3969 mainCtrl.wait_registry_empty(t, 10)
3971 mainCtrl.VerifyCounterValues(t)
3974 //-----------------------------------------------------------------------------
3975 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
3978 // +-------+ +---------+ +---------+
3979 // | xapp | | submgr | | e2term |
3980 // +-------+ +---------+ +---------+
3983 // |---------------->| |
3985 // | RESTSubResp | |
3986 // |<----------------| |
3988 // | |------------->|
3991 // | |<-------------|
3994 // |<----------------| |
3997 // | Submgr restart |
3999 // | RESTSubDelReq | |
4000 // |---------------->| |
4003 // | |------------->|
4006 // | |<-------------|
4008 // | RESTSubDelResp | |
4009 // |<----------------| |
4011 //-----------------------------------------------------------------------------
4012 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
4013 CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle")
4015 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4016 Counter{cSubReqFromXapp, 1},
4017 Counter{cSubReqToE2, 1},
4018 Counter{cSubRespFromE2, 1},
4019 Counter{cSubRespToXapp, 1},
4020 Counter{cSubDelReqFromXapp, 1},
4021 Counter{cSubDelReqToE2, 1},
4022 Counter{cSubDelRespToXapp, 1},
4025 // Remove possible existing subscription
4026 mainCtrl.removeExistingSubscriptions(t)
4028 var params *teststube2ap.RESTSubsReqParams = nil
4030 // Create subscription
4031 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4032 xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
4034 // Check subscription
4035 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4037 // When SDL support for the REST Interface is added
4038 // the submgr restart statement below should be removed
4039 // from the comment.
4041 // mainCtrl.SimulateRestart(t)
4042 // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4044 // Check subscription
4045 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4047 // Delete subscription
4048 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
4050 //Wait that subs is cleaned
4051 waitSubsCleanup(t, e2SubsId, 10)
4053 mainCtrl.VerifyCounterValues(t)
4056 //-----------------------------------------------------------------------------
4057 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
4060 // +-------+ +-------+ +---------+ +---------+
4061 // | xapp2 | | xapp1 | | submgr | | e2term |
4062 // +-------+ +-------+ +---------+ +---------+
4064 // | | RESTSubReq1 | |
4065 // | |---------------->| |
4067 // | | RESTSubResp1 | |
4068 // | |<----------------| |
4071 // | | |------------->|
4073 // | | |<-------------|
4074 // | | RESTNotif1 | |
4075 // | |<----------------| |
4077 // | RESTSubReq2 | |
4078 // |------------------------------>| |
4080 // | RESTSubResp2 | |
4081 // |<------------------------------| |
4083 // | | RESTNotif2 | |
4084 // |<------------------------------| |
4086 // | | Submgr restart |
4088 // | | RESTSubDelReq1 | |
4089 // | |---------------->| |
4091 // | | RESTSubDelResp1 | |
4092 // | |<----------------| |
4094 // | | Submgr restart |
4096 // | RESTSubDelReq2 | |
4097 // |------------------------------>| |
4099 // | RESTSubDelResp2 | |
4100 // |<------------------------------| |
4102 // | | | SubDelReq2 |
4103 // | | |------------->|
4105 // | | | SubDelResp2 |
4106 // | | |<-------------|
4109 //-----------------------------------------------------------------------------
4110 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
4111 CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
4113 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4114 Counter{cSubReqFromXapp, 2},
4115 Counter{cSubReqToE2, 1},
4116 Counter{cSubRespFromE2, 1},
4117 Counter{cSubRespToXapp, 2},
4118 Counter{cMergedSubscriptions, 1},
4119 Counter{cUnmergedSubscriptions, 1},
4120 Counter{cSubDelReqFromXapp, 2},
4121 Counter{cSubDelReqToE2, 1},
4122 Counter{cSubDelRespFromE2, 1},
4123 Counter{cSubDelRespToXapp, 2},
4126 // Remove possible existing subscription
4127 mainCtrl.removeExistingSubscriptions(t)
4129 var params *teststube2ap.RESTSubsReqParams = nil
4131 // Create subscription 1
4132 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4133 xapp.Logger.Info("Send REST subscriber request for subscriber 1 : %v", restSubId1)
4135 // Create subscription 2 with same action
4136 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4137 params.SetMeid("RAN_NAME_1")
4138 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4139 xappConn2.WaitRESTNotificationForAnySubscriptionId(t)
4140 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4141 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4142 e2SubsId2 := <-xappConn2.RESTNotification
4143 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
4145 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
4147 // When SDL support for the REST Interface is added
4148 // the submgr restart statement below should be removed
4149 // from the comment.
4151 // mainCtrl.SimulateRestart(t)
4152 // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4154 // Delete subscription 1, and wait until it has removed the first endpoint
4155 subepcnt := mainCtrl.get_subs_entrypoint_cnt(t, e2SubsId1)
4156 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4157 mainCtrl.wait_subs_entrypoint_cnt_change(t, e2SubsId1, subepcnt, 10)
4159 // When SDL support for the REST Interface is added
4160 // the submgr restart statement below should be removed
4161 // from the comment.
4163 // mainCtrl.SimulateRestart(t)
4164 // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4165 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
4167 // Delete subscription 2
4168 deleteXapp2Subscription(t, &restSubId2)
4170 //Wait that subs is cleaned
4171 waitSubsCleanup(t, e2SubsId2, 10)
4173 mainCtrl.VerifyCounterValues(t)
4176 //-----------------------------------------------------------------------------
4177 // TestRESTReportSubReqAndSubDelOk
4180 // +-------+ +---------+ +---------+
4181 // | xapp | | submgr | | e2term |
4182 // +-------+ +---------+ +---------+
4185 // |---------------->| |
4187 // | RESTSubResp | |
4188 // |<----------------| |
4191 // | |------------->|
4194 // | |<-------------|
4196 // |<----------------| |
4198 // | |------------->|
4201 // | |<-------------|
4203 // |<----------------| |
4207 // | RESTSubDelReq | |
4208 // |---------------->| |
4211 // | |------------->|
4214 // | |<-------------|
4216 // | RESTSubDelResp| |
4217 // |<----------------| |
4219 //-----------------------------------------------------------------------------
4220 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
4221 CaseBegin("TestRESTReportSubReqAndSubDelOk")
4224 RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
4227 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
4228 xapp.Logger.Info("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
4231 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4232 restSubId := xappConn1.SendRESTSubsReq(t, params)
4234 var e2SubsId []uint32
4235 for i := 0; i < subReqCount; i++ {
4236 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4237 xappConn1.ExpectRESTNotification(t, restSubId)
4239 e2termConn1.SendSubsResp(t, crereq, cremsg)
4240 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
4241 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
4242 e2SubsId = append(e2SubsId, instanceId)
4243 resp, _ := xapp.Subscription.QuerySubscriptions()
4244 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
4245 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
4246 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
4251 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4253 for i := 0; i < subReqCount; i++ {
4254 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4255 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4258 // Wait that subs is cleaned
4259 for i := 0; i < subReqCount; i++ {
4260 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
4263 xappConn1.TestMsgChanEmpty(t)
4264 e2termConn1.TestMsgChanEmpty(t)
4265 mainCtrl.wait_registry_empty(t, 10)
4269 func TestRESTPolicySubReqAndSubDelOk(t *testing.T) {
4270 CaseBegin("TestRESTPolicySubReqAndSubDelOk")
4274 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
4278 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
4281 func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
4282 xapp.Logger.Info("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
4285 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4286 restSubId := xappConn1.SendRESTSubsReq(t, params)
4287 //params := xappConn1.GetRESTSubsReqPolicyParams1(subReqCount)
4288 //restSubId := xappConn1.SendRESTPolicySubsReq(t, params)
4290 var e2SubsId []uint32
4291 for i := 0; i < subReqCount; i++ {
4292 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4293 xappConn1.ExpectRESTNotification(t, restSubId)
4294 e2termConn1.SendSubsResp(t, crereq, cremsg)
4295 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
4296 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
4297 e2SubsId = append(e2SubsId, instanceId)
4301 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4303 for i := 0; i < subReqCount; i++ {
4304 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4305 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4308 // Wait that subs is cleaned
4309 for i := 0; i < subReqCount; i++ {
4310 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
4312 xappConn1.TestMsgChanEmpty(t)
4313 e2termConn1.TestMsgChanEmpty(t)
4314 mainCtrl.wait_registry_empty(t, 10)
4317 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
4321 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4322 Counter{cSubReqFromXapp, 1},
4323 Counter{cSubReqToE2, 2},
4324 Counter{cSubRespFromE2, 2},
4325 Counter{cSubRespToXapp, 2},
4326 Counter{cSubDelReqFromXapp, 1},
4327 Counter{cSubDelReqToE2, 2},
4328 Counter{cSubDelRespFromE2, 2},
4329 Counter{cSubDelRespToXapp, 1},
4333 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4334 restSubId := xappConn1.SendRESTSubsReq(t, params)
4335 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4337 assert.Equal(t, len(e2SubsIds), 2)
4340 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4341 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4343 xappConn1.TestMsgChanEmpty(t)
4344 e2termConn1.TestMsgChanEmpty(t)
4345 mainCtrl.wait_registry_empty(t, 10)
4347 mainCtrl.VerifyCounterValues(t)
4349 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
4353 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4354 Counter{cSubReqFromXapp, 1},
4355 Counter{cSubReqToE2, 19},
4356 Counter{cSubRespFromE2, 19},
4357 Counter{cSubRespToXapp, 19},
4358 Counter{cSubDelReqFromXapp, 1},
4359 Counter{cSubDelReqToE2, 19},
4360 Counter{cSubDelRespFromE2, 19},
4361 Counter{cSubDelRespToXapp, 1},
4365 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4366 restSubId := xappConn1.SendRESTSubsReq(t, params)
4367 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4369 assert.Equal(t, len(e2SubsIds), 19)
4371 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4372 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4374 xappConn1.TestMsgChanEmpty(t)
4375 e2termConn1.TestMsgChanEmpty(t)
4376 mainCtrl.wait_registry_empty(t, 10)
4378 mainCtrl.VerifyCounterValues(t)
4380 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
4384 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4385 Counter{cSubReqFromXapp, 1},
4386 Counter{cSubReqToE2, uint64(subReqCount)},
4387 Counter{cSubRespFromE2, uint64(subReqCount)},
4388 Counter{cSubRespToXapp, uint64(subReqCount)},
4389 Counter{cSubDelReqFromXapp, 1},
4390 Counter{cSubDelReqToE2, uint64(subReqCount)},
4391 Counter{cSubDelRespFromE2, uint64(subReqCount)},
4392 Counter{cSubDelRespToXapp, 1},
4396 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4397 restSubId := xappConn1.SendRESTSubsReq(t, params)
4398 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4400 assert.Equal(t, len(e2SubsIds), subReqCount)
4403 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4404 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4406 xappConn1.TestMsgChanEmpty(t)
4407 e2termConn1.TestMsgChanEmpty(t)
4408 mainCtrl.wait_registry_empty(t, 10)
4410 mainCtrl.VerifyCounterValues(t)
4413 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
4417 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4418 Counter{cSubReqFromXapp, 1},
4419 Counter{cSubReqToE2, uint64(subReqCount)},
4420 Counter{cSubRespFromE2, uint64(subReqCount)},
4421 Counter{cSubRespToXapp, uint64(subReqCount)},
4422 Counter{cSubDelReqFromXapp, 1},
4423 Counter{cSubDelReqToE2, uint64(subReqCount)},
4424 Counter{cSubDelRespFromE2, uint64(subReqCount)},
4425 Counter{cSubDelRespToXapp, 1},
4429 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4430 restSubId := xappConn1.SendRESTSubsReq(t, params)
4431 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4433 assert.Equal(t, len(e2SubsIds), subReqCount)
4436 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4437 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4439 xappConn1.TestMsgChanEmpty(t)
4440 e2termConn1.TestMsgChanEmpty(t)
4441 mainCtrl.wait_registry_empty(t, 10)
4443 mainCtrl.VerifyCounterValues(t)
4446 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
4450 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4451 Counter{cSubReqFromXapp, 1},
4452 Counter{cSubReqToE2, uint64(subReqCount)},
4453 Counter{cSubRespFromE2, uint64(subReqCount)},
4454 Counter{cSubRespToXapp, uint64(subReqCount)},
4455 Counter{cSubDelReqFromXapp, 1},
4456 Counter{cSubDelReqToE2, uint64(subReqCount)},
4457 Counter{cSubDelRespFromE2, uint64(subReqCount)},
4458 Counter{cSubDelRespToXapp, 1},
4462 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4463 restSubId := xappConn1.SendRESTSubsReq(t, params)
4464 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4466 assert.Equal(t, len(e2SubsIds), subReqCount)
4469 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4470 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4472 xappConn1.TestMsgChanEmpty(t)
4473 e2termConn1.TestMsgChanEmpty(t)
4474 mainCtrl.wait_registry_empty(t, 10)
4476 mainCtrl.VerifyCounterValues(t)
4479 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
4480 CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
4482 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4483 Counter{cSubReqFromXapp, 2},
4484 Counter{cSubReqToE2, 2},
4485 Counter{cSubRespFromE2, 2},
4486 Counter{cSubRespToXapp, 2},
4487 Counter{cSubDelReqFromXapp, 2},
4488 Counter{cSubDelReqToE2, 2},
4489 Counter{cSubDelRespFromE2, 2},
4490 Counter{cSubDelRespToXapp, 2},
4494 var params *teststube2ap.RESTSubsReqParams = nil
4497 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4498 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4500 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4503 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4504 params.SetMeid("RAN_NAME_1")
4505 eventTriggerDefinition := "1234"
4506 params.SetSubEventTriggerDefinition(eventTriggerDefinition)
4508 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4509 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4510 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4511 xappConn2.ExpectRESTNotification(t, restSubId2)
4512 e2termConn1.SendSubsResp(t, crereq, cremsg)
4513 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4515 deleteXapp1Subscription(t, &restSubId1)
4516 deleteXapp2Subscription(t, &restSubId2)
4518 waitSubsCleanup(t, e2SubsId1, 10)
4519 waitSubsCleanup(t, e2SubsId2, 10)
4521 mainCtrl.VerifyCounterValues(t)
4525 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
4526 CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
4528 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4529 Counter{cSubReqFromXapp, 2},
4530 Counter{cSubReqToE2, 2},
4531 Counter{cSubRespFromE2, 2},
4532 Counter{cSubRespToXapp, 2},
4533 Counter{cSubDelReqFromXapp, 2},
4534 Counter{cSubDelReqToE2, 2},
4535 Counter{cSubDelRespFromE2, 2},
4536 Counter{cSubDelRespToXapp, 2},
4540 var params *teststube2ap.RESTSubsReqParams = nil
4543 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4544 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4546 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4549 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4550 params.SetMeid("RAN_NAME_1")
4552 actionId := int64(1)
4553 actionType := "report"
4554 actionDefinition := "56781"
4555 subsequestActionType := "continue"
4556 timeToWait := "w10ms"
4557 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
4559 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4560 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4561 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4562 xappConn2.ExpectRESTNotification(t, restSubId2)
4563 e2termConn1.SendSubsResp(t, crereq, cremsg)
4564 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4566 deleteXapp1Subscription(t, &restSubId1)
4567 deleteXapp2Subscription(t, &restSubId2)
4569 waitSubsCleanup(t, e2SubsId1, 10)
4570 waitSubsCleanup(t, e2SubsId2, 10)
4572 mainCtrl.VerifyCounterValues(t)
4576 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
4577 CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
4579 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4580 Counter{cSubReqFromXapp, 2},
4581 Counter{cSubReqToE2, 2},
4582 Counter{cSubRespFromE2, 2},
4583 Counter{cSubRespToXapp, 2},
4584 Counter{cSubDelReqFromXapp, 2},
4585 Counter{cSubDelReqToE2, 2},
4586 Counter{cSubDelRespFromE2, 2},
4587 Counter{cSubDelRespToXapp, 2},
4591 var params *teststube2ap.RESTSubsReqParams = nil
4594 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4595 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4597 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4600 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4601 params.SetMeid("RAN_NAME_1")
4602 params.SetSubActionIDs(int64(2))
4604 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4605 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4606 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4607 xappConn2.ExpectRESTNotification(t, restSubId2)
4608 e2termConn1.SendSubsResp(t, crereq, cremsg)
4609 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4611 deleteXapp1Subscription(t, &restSubId1)
4612 deleteXapp2Subscription(t, &restSubId2)
4614 waitSubsCleanup(t, e2SubsId1, 10)
4615 waitSubsCleanup(t, e2SubsId2, 10)
4617 mainCtrl.VerifyCounterValues(t)
4621 func TestRESTSubReqDiffActionType(t *testing.T) {
4622 CaseBegin("TestRESTSubReqDiffActionType")
4624 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4625 Counter{cSubReqFromXapp, 2},
4626 Counter{cSubReqToE2, 2},
4627 Counter{cSubRespFromE2, 2},
4628 Counter{cSubRespToXapp, 2},
4629 Counter{cSubDelReqFromXapp, 2},
4630 Counter{cSubDelReqToE2, 2},
4631 Counter{cSubDelRespFromE2, 2},
4632 Counter{cSubDelRespToXapp, 2},
4636 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4639 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4640 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4642 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4645 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4646 params.SetMeid("RAN_NAME_1")
4648 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4649 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4650 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4651 xappConn2.ExpectRESTNotification(t, restSubId2)
4652 e2termConn1.SendSubsResp(t, crereq, cremsg)
4653 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4655 deleteXapp1Subscription(t, &restSubId1)
4656 deleteXapp2Subscription(t, &restSubId2)
4658 waitSubsCleanup(t, e2SubsId1, 10)
4659 waitSubsCleanup(t, e2SubsId2, 10)
4661 mainCtrl.VerifyCounterValues(t)
4665 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
4666 CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
4668 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4669 Counter{cSubReqFromXapp, 2},
4670 Counter{cSubReqToE2, 2},
4671 Counter{cSubRespFromE2, 2},
4672 Counter{cSubRespToXapp, 2},
4673 Counter{cSubDelReqFromXapp, 2},
4674 Counter{cSubDelReqToE2, 2},
4675 Counter{cSubDelRespFromE2, 2},
4676 Counter{cSubDelRespToXapp, 2},
4680 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4683 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4684 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4686 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4689 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
4690 params.SetMeid("RAN_NAME_1")
4692 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4693 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4694 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4695 xappConn2.ExpectRESTNotification(t, restSubId2)
4696 e2termConn1.SendSubsResp(t, crereq, cremsg)
4697 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4699 deleteXapp1Subscription(t, &restSubId1)
4700 deleteXapp2Subscription(t, &restSubId2)
4702 waitSubsCleanup(t, e2SubsId1, 10)
4703 waitSubsCleanup(t, e2SubsId2, 10)
4705 mainCtrl.VerifyCounterValues(t)
4709 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
4710 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
4712 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4713 Counter{cSubReqFromXapp, 2},
4714 Counter{cSubReqToE2, 2},
4715 Counter{cSubRespFromE2, 2},
4716 Counter{cSubRespToXapp, 2},
4717 Counter{cSubDelReqFromXapp, 2},
4718 Counter{cSubDelReqToE2, 2},
4719 Counter{cSubDelRespFromE2, 2},
4720 Counter{cSubDelRespToXapp, 2},
4724 var params *teststube2ap.RESTSubsReqParams = nil
4727 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4728 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4730 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4733 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4734 params.SetMeid("RAN_NAME_1")
4735 actionDefinition := "5678"
4736 params.SetSubActionDefinition(actionDefinition)
4738 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4739 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4740 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4741 xappConn2.ExpectRESTNotification(t, restSubId2)
4742 e2termConn1.SendSubsResp(t, crereq, cremsg)
4743 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4745 deleteXapp1Subscription(t, &restSubId1)
4746 deleteXapp2Subscription(t, &restSubId2)
4748 waitSubsCleanup(t, e2SubsId1, 10)
4749 waitSubsCleanup(t, e2SubsId2, 10)
4751 mainCtrl.VerifyCounterValues(t)
4755 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
4756 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
4758 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4759 Counter{cSubReqFromXapp, 2},
4760 Counter{cSubReqToE2, 2},
4761 Counter{cSubRespFromE2, 2},
4762 Counter{cSubRespToXapp, 2},
4763 Counter{cSubDelReqFromXapp, 2},
4764 Counter{cSubDelReqToE2, 2},
4765 Counter{cSubDelRespFromE2, 2},
4766 Counter{cSubDelRespToXapp, 2},
4770 var params *teststube2ap.RESTSubsReqParams = nil
4773 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4774 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4776 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4779 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4780 params.SetMeid("RAN_NAME_1")
4781 actionDefinition := "56782"
4782 params.SetSubActionDefinition(actionDefinition)
4784 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4785 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4786 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4787 xappConn2.ExpectRESTNotification(t, restSubId2)
4788 e2termConn1.SendSubsResp(t, crereq, cremsg)
4789 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4791 deleteXapp1Subscription(t, &restSubId1)
4792 deleteXapp2Subscription(t, &restSubId2)
4794 waitSubsCleanup(t, e2SubsId1, 10)
4795 waitSubsCleanup(t, e2SubsId2, 10)
4797 mainCtrl.VerifyCounterValues(t)
4801 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
4802 CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
4804 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4805 Counter{cSubReqFromXapp, 2},
4806 Counter{cSubReqToE2, 2},
4807 Counter{cSubRespFromE2, 2},
4808 Counter{cSubRespToXapp, 2},
4809 Counter{cSubDelReqFromXapp, 2},
4810 Counter{cSubDelReqToE2, 2},
4811 Counter{cSubDelRespFromE2, 2},
4812 Counter{cSubDelRespToXapp, 2},
4816 var params *teststube2ap.RESTSubsReqParams = nil
4819 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4820 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4822 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4825 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4826 params.SetMeid("RAN_NAME_1")
4827 params.SetTimeToWait("w200ms")
4828 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4829 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4830 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4831 xappConn2.ExpectRESTNotification(t, restSubId2)
4832 e2termConn1.SendSubsResp(t, crereq, cremsg)
4833 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4835 deleteXapp1Subscription(t, &restSubId1)
4836 deleteXapp2Subscription(t, &restSubId2)
4838 waitSubsCleanup(t, e2SubsId1, 10)
4839 waitSubsCleanup(t, e2SubsId2, 10)
4841 mainCtrl.VerifyCounterValues(t)
4845 //-----------------------------------------------------------------------------
4846 // TestRESTUnpackSubscriptionResponseDecodeFail
4849 // +-------+ +---------+ +---------+
4850 // | xapp | | submgr | | e2term |
4851 // +-------+ +---------+ +---------+
4854 // |---------------->| |
4856 // | RESTSubResp | |
4857 // |<----------------| |
4860 // | |------------->|
4862 // | | SubResp | ASN.1 decode fails
4863 // | |<-------------|
4866 // | |------------->|
4868 // | | SubFail | Duplicated action
4869 // | |<-------------|
4870 // | RESTNotif (fail)| |
4871 // |<----------------| |
4873 // | |------------->|
4876 // | |<-------------|
4878 //-----------------------------------------------------------------------------
4879 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
4880 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
4884 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4885 restSubId := xappConn1.SendRESTSubsReq(t, params)
4887 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4888 // Decode of this response fails which will result resending original request
4889 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
4891 _, cremsg = e2termConn1.RecvSubsReq(t)
4893 xappConn1.ExpectRESTNotification(t, restSubId)
4895 // Subscription already created in E2 Node.
4896 fparams := &teststube2ap.E2StubSubsFailParams{}
4898 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
4899 e2termConn1.SendSubsFail(t, fparams, cremsg)
4901 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4902 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4904 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
4905 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
4907 // Wait that subs is cleaned
4908 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
4910 xappConn1.TestMsgChanEmpty(t)
4911 e2termConn1.TestMsgChanEmpty(t)
4912 mainCtrl.wait_registry_empty(t, 10)
4915 //-----------------------------------------------------------------------------
4916 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
4919 // +-------+ +---------+ +---------+
4920 // | xapp | | submgr | | e2term |
4921 // +-------+ +---------+ +---------+
4924 // |---------------->| |
4926 // | RESTSubResp | |
4927 // |<----------------| |
4930 // | |------------->|
4932 // | | SubResp | Unknown instanceId
4933 // | |<-------------|
4936 // | |------------->|
4938 // | | SubFail | Duplicated action
4939 // | |<-------------|
4940 // | RESTNotif (fail)| |
4941 // |<----------------| |
4943 // | |------------->|
4946 // | |<-------------|
4948 //-----------------------------------------------------------------------------
4949 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
4950 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
4954 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4955 restSubId := xappConn1.SendRESTSubsReq(t, params)
4957 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4959 // Unknown instanceId in this response which will result resending original request
4960 orgInstanceId := crereq.RequestId.InstanceId
4961 crereq.RequestId.InstanceId = 0
4962 e2termConn1.SendSubsResp(t, crereq, cremsg)
4964 _, cremsg = e2termConn1.RecvSubsReq(t)
4966 xappConn1.ExpectRESTNotification(t, restSubId)
4968 // Subscription already created in E2 Node.
4969 fparams := &teststube2ap.E2StubSubsFailParams{}
4971 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
4972 e2termConn1.SendSubsFail(t, fparams, cremsg)
4974 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4975 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4977 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
4978 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
4980 // Wait that subs is cleaned
4981 mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
4983 xappConn1.TestMsgChanEmpty(t)
4984 e2termConn1.TestMsgChanEmpty(t)
4985 mainCtrl.wait_registry_empty(t, 10)
4988 //-----------------------------------------------------------------------------
4989 // TestRESTUnpackSubscriptionResponseNoTransaction
4992 // +-------+ +---------+ +---------+
4993 // | xapp | | submgr | | e2term |
4994 // +-------+ +---------+ +---------+
4997 // |---------------->| |
4999 // | RESTSubResp | |
5000 // |<----------------| |
5003 // | |------------->|
5005 // | | SubResp | No transaction for the response
5006 // | |<-------------|
5009 // | |------------->|
5011 // | | SubFail | Duplicated action
5012 // | |<-------------|
5013 // | RESTNotif (fail)| |
5014 // |<----------------| |
5016 // | |------------->|
5019 // | |<-------------|
5022 // | |------------->|
5025 // | |<-------------|
5027 //-----------------------------------------------------------------------------
5028 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
5029 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
5033 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5034 restSubId := xappConn1.SendRESTSubsReq(t, params)
5036 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5038 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
5039 // No transaction exist for this response which will result resending original request
5040 e2termConn1.SendSubsResp(t, crereq, cremsg)
5042 _, cremsg = e2termConn1.RecvSubsReq(t)
5044 xappConn1.ExpectRESTNotification(t, restSubId)
5046 // Subscription already created in E2 Node.
5047 fparams := &teststube2ap.E2StubSubsFailParams{}
5049 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5050 e2termConn1.SendSubsFail(t, fparams, cremsg)
5052 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5053 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5055 // Resending happens because there no transaction
5056 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5057 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5059 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5060 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5062 // Wait that subs is cleaned
5063 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5065 xappConn1.TestMsgChanEmpty(t)
5066 e2termConn1.TestMsgChanEmpty(t)
5067 mainCtrl.wait_registry_empty(t, 10)
5071 //-----------------------------------------------------------------------------
5072 // TestRESTUnpackSubscriptionFailureDecodeFail
5075 // +-------+ +---------+ +---------+
5076 // | xapp | | submgr | | e2term |
5077 // +-------+ +---------+ +---------+
5080 // |---------------->| |
5082 // | RESTSubResp | |
5083 // |<----------------| |
5086 // | |------------->|
5088 // | | SubFail | ASN.1 decode fails
5089 // | |<-------------|
5092 // | |------------->|
5094 // | | SubFail | Duplicated action
5095 // | |<-------------|
5096 // | RESTNotif (fail)| |
5097 // |<----------------| |
5099 // | |------------->|
5102 // | |<-------------|
5104 //-----------------------------------------------------------------------------
5105 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
5106 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
5110 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5111 restSubId := xappConn1.SendRESTSubsReq(t, params)
5113 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5115 // Decode of this response fails which will result resending original request
5116 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
5118 _, cremsg = e2termConn1.RecvSubsReq(t)
5120 xappConn1.ExpectRESTNotification(t, restSubId)
5122 // Subscription already created in E2 Node.
5123 fparams := &teststube2ap.E2StubSubsFailParams{}
5125 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5126 e2termConn1.SendSubsFail(t, fparams, cremsg)
5128 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5129 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5131 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5132 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5134 // Wait that subs is cleaned
5135 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5137 xappConn1.TestMsgChanEmpty(t)
5138 e2termConn1.TestMsgChanEmpty(t)
5139 mainCtrl.wait_registry_empty(t, 10)
5142 //-----------------------------------------------------------------------------
5143 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
5146 // +-------+ +---------+ +---------+
5147 // | xapp | | submgr | | e2term |
5148 // +-------+ +---------+ +---------+
5151 // |---------------->| |
5153 // | RESTSubResp | |
5154 // |<----------------| |
5157 // | |------------->|
5159 // | | SubFail | Unknown instanceId
5160 // | |<-------------|
5163 // | |------------->|
5165 // | | SubFail | Duplicated action
5166 // | |<-------------|
5167 // | RESTNotif (fail)| |
5168 // |<----------------| |
5170 // | |------------->|
5173 // | |<-------------|
5175 //-----------------------------------------------------------------------------
5176 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
5177 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
5181 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5182 restSubId := xappConn1.SendRESTSubsReq(t, params)
5184 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5186 // Unknown instanceId in this response which will result resending original request
5187 fparams := &teststube2ap.E2StubSubsFailParams{}
5189 fparams.Fail.RequestId.InstanceId = 0
5190 e2termConn1.SendSubsFail(t, fparams, cremsg)
5192 _, cremsg = e2termConn1.RecvSubsReq(t)
5194 xappConn1.ExpectRESTNotification(t, restSubId)
5196 // Subscription already created in E2 Node.
5197 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5198 e2termConn1.SendSubsFail(t, fparams, cremsg)
5200 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5201 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5203 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5204 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5206 // Wait that subs is cleaned
5207 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5209 xappConn1.TestMsgChanEmpty(t)
5210 e2termConn1.TestMsgChanEmpty(t)
5211 mainCtrl.wait_registry_empty(t, 10)
5214 //-----------------------------------------------------------------------------
5215 // TestRESTUnpackSubscriptionFailureNoTransaction
5218 // +-------+ +---------+ +---------+
5219 // | xapp | | submgr | | e2term |
5220 // +-------+ +---------+ +---------+
5223 // |---------------->| |
5225 // | RESTSubResp | |
5226 // |<----------------| |
5229 // | |------------->|
5231 // | | SubFail | No transaction for the response
5232 // | |<-------------|
5235 // | |------------->|
5237 // | | SubFail | Duplicated action
5238 // | |<-------------|
5239 // | RESTNotif (fail)| |
5240 // |<----------------| |
5242 // | |------------->|
5245 // | |<-------------|
5247 //-----------------------------------------------------------------------------
5248 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
5249 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
5253 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5254 restSubId := xappConn1.SendRESTSubsReq(t, params)
5256 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5258 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
5260 // No transaction exist for this response which will result resending original request
5261 fparams := &teststube2ap.E2StubSubsFailParams{}
5263 e2termConn1.SendSubsFail(t, fparams, cremsg)
5265 _, cremsg = e2termConn1.RecvSubsReq(t)
5267 xappConn1.ExpectRESTNotification(t, restSubId)
5269 // Subscription already created in E2 Node.
5270 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5271 e2termConn1.SendSubsFail(t, fparams, cremsg)
5273 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5274 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5276 // Resending happens because there no transaction
5277 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5278 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5280 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5281 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5283 // Wait that subs is cleaned
5284 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5286 xappConn1.TestMsgChanEmpty(t)
5287 e2termConn1.TestMsgChanEmpty(t)
5288 mainCtrl.wait_registry_empty(t, 10)
5291 //-----------------------------------------------------------------------------
5292 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
5295 // +-------+ +---------+ +---------+
5296 // | xapp | | submgr | | e2term |
5297 // +-------+ +---------+ +---------+
5299 // | [SUBS CREATE] |
5302 // | RESTSubDelReq | |
5303 // |---------------->| |
5305 // | RESTSubDelResp | |
5306 // |<----------------| |
5309 // | |------------->|
5311 // | | SubDelResp | ASN.1 decode fails
5312 // | |<-------------|
5315 // | |------------->|
5317 // | | SubDelFail | Subscription does exist any more
5318 // | |<-------------|
5321 //-----------------------------------------------------------------------------
5322 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
5323 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail")
5326 var params *teststube2ap.RESTSubsReqParams = nil
5327 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5330 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5332 // E2t: Receive 1st SubsDelReq
5333 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5335 // Decode of this response fails which will result resending original request
5336 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_REQ)
5338 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
5339 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5341 // Subscription does not exist in in E2 Node.
5342 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5344 // Wait that subs is cleaned
5345 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5347 xappConn1.TestMsgChanEmpty(t)
5348 e2termConn1.TestMsgChanEmpty(t)
5349 mainCtrl.wait_registry_empty(t, 10)
5352 //-----------------------------------------------------------------------------
5353 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
5356 // +-------+ +---------+ +---------+
5357 // | xapp | | submgr | | e2term |
5358 // +-------+ +---------+ +---------+
5360 // | [SUBS CREATE] |
5363 // | RESTSubDelReq | |
5364 // |---------------->| |
5366 // | RESTSubDelResp | |
5367 // |<----------------| |
5370 // | |------------->|
5372 // | | SubDelResp | Unknown instanceId
5373 // | |<-------------|
5376 // | |------------->|
5378 // | | SubDelFail | Subscription does exist any more
5379 // | |<-------------|
5381 //-----------------------------------------------------------------------------
5382 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
5383 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId")
5386 var params *teststube2ap.RESTSubsReqParams = nil
5387 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5390 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5392 // E2t: Receive 1st SubsDelReq
5393 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5395 // Unknown instanceId in this response which will result resending original request
5396 delreq.RequestId.InstanceId = 0
5397 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5399 // E2t: Receive 2nd SubsDelReq
5400 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5402 // Subscription does not exist in in E2 Node.
5403 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5405 // Wait that subs is cleaned
5406 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5408 xappConn1.TestMsgChanEmpty(t)
5409 e2termConn1.TestMsgChanEmpty(t)
5410 mainCtrl.wait_registry_empty(t, 10)
5413 //-----------------------------------------------------------------------------
5414 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
5417 // +-------+ +---------+ +---------+
5418 // | xapp | | submgr | | e2term |
5419 // +-------+ +---------+ +---------+
5421 // | [SUBS CREATE] |
5424 // | RESTSubDelReq | |
5425 // |---------------->| |
5427 // | RESTSubDelResp | |
5428 // |<----------------| |
5431 // | |------------->|
5433 // | | SubDelResp | No transaction for the response
5434 // | |<-------------|
5437 // | |------------->|
5439 // | | SubDelFail | Subscription does exist any more
5440 // | |<-------------|
5442 //-----------------------------------------------------------------------------
5443 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
5444 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction")
5447 var params *teststube2ap.RESTSubsReqParams = nil
5448 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5451 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5453 // E2t: Receive 1st SubsDelReq
5454 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5456 mainCtrl.MakeTransactionNil(t, e2SubsId)
5458 // No transaction exist for this response which will result resending original request
5459 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5461 // E2t: Receive 2nd SubsDelReq
5462 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5464 // Subscription does not exist in in E2 Node.
5465 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5467 // Wait that subs is cleaned
5468 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5470 xappConn1.TestMsgChanEmpty(t)
5471 e2termConn1.TestMsgChanEmpty(t)
5472 mainCtrl.wait_registry_empty(t, 10)
5475 //-----------------------------------------------------------------------------
5476 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
5479 // +-------+ +---------+ +---------+
5480 // | xapp | | submgr | | e2term |
5481 // +-------+ +---------+ +---------+
5483 // | [SUBS CREATE] |
5486 // | RESTSubDelReq | |
5487 // |---------------->| |
5489 // | RESTSubDelResp | |
5490 // |<----------------| |
5493 // | |------------->|
5495 // | | SubDelFail | ASN.1 decode fails
5496 // | |<-------------|
5499 // | |------------->|
5501 // | | SubDelFail | Subscription does exist any more
5502 // | |<-------------|
5504 //-----------------------------------------------------------------------------
5505 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
5506 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail")
5509 var params *teststube2ap.RESTSubsReqParams = nil
5510 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5513 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5515 // E2t: Receive 1st SubsDelReq
5516 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5518 // Decode of this response fails which will result resending original request
5519 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
5521 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
5522 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5524 // Subscription does not exist in in E2 Node.
5525 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5527 // Wait that subs is cleaned
5528 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5530 xappConn1.TestMsgChanEmpty(t)
5531 e2termConn1.TestMsgChanEmpty(t)
5532 mainCtrl.wait_registry_empty(t, 10)
5535 //-----------------------------------------------------------------------------
5536 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
5539 // +-------+ +---------+ +---------+
5540 // | xapp | | submgr | | e2term |
5541 // +-------+ +---------+ +---------+
5543 // | [SUBS CREATE] |
5546 // | RESTSubDelReq | |
5547 // |---------------->| |
5549 // | RESTSubDelResp | |
5550 // |<----------------| |
5553 // | |------------->|
5555 // | | SubDelFail | Unknown instanceId
5556 // | |<-------------|
5559 // | |------------->|
5561 // | | SubDelFail | Subscription does exist any more
5562 // | |<-------------|
5564 //-----------------------------------------------------------------------------
5565 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
5566 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId")
5569 var params *teststube2ap.RESTSubsReqParams = nil
5570 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5573 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5575 // E2t: Receive 1st SubsDelReq
5576 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5578 // Unknown instanceId in this response which will result resending original request
5579 delreq.RequestId.InstanceId = 0
5580 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5582 // E2t: Receive 2nd SubsDelReq
5583 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5585 // Subscription does not exist in in E2 Node.
5586 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5588 // Wait that subs is cleaned
5589 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5591 xappConn1.TestMsgChanEmpty(t)
5592 e2termConn1.TestMsgChanEmpty(t)
5593 mainCtrl.wait_registry_empty(t, 10)
5596 //-----------------------------------------------------------------------------
5597 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
5600 // +-------+ +---------+ +---------+
5601 // | xapp | | submgr | | e2term |
5602 // +-------+ +---------+ +---------+
5604 // | [SUBS CREATE] |
5607 // | RESTSubDelReq | |
5608 // |---------------->| |
5610 // | RESTSubDelResp | |
5611 // |<----------------| |
5614 // | |------------->|
5616 // | | SubDelFail | No transaction for the response
5617 // | |<-------------|
5620 // | |------------->|
5622 // | | SubDelFail | Subscription does exist any more
5623 // | |<-------------|
5625 //-----------------------------------------------------------------------------
5626 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
5627 xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction")
5630 var params *teststube2ap.RESTSubsReqParams = nil
5631 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5634 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5636 // E2t: Receive 1st SubsDelReq
5637 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5639 mainCtrl.MakeTransactionNil(t, e2SubsId)
5641 // No transaction exist for this response which will result resending original request
5642 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5644 // E2t: Receive 2nd SubsDelReq
5645 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5647 // Subscription does not exist in in E2 Node.
5648 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5650 // Wait that subs is cleaned
5651 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5653 xappConn1.TestMsgChanEmpty(t)
5654 e2termConn1.TestMsgChanEmpty(t)
5655 mainCtrl.wait_registry_empty(t, 10)
5658 //-----------------------------------------------------------------------------
5659 // TestRESTSubReqFailAsn1PackSubReqError
5662 // +-------+ +---------+ +---------+
5663 // | xapp | | submgr | | e2term |
5664 // +-------+ +---------+ +---------+
5667 // |---------------->| |
5669 // | RESTSubResp | |
5670 // |<----------------| |
5672 // | ASN.1 encode fails |
5675 // | |------------->|
5678 // | |<-------------|
5682 // |<----------------| |
5684 // | [SUBS DELETE] |
5687 //-----------------------------------------------------------------------------
5688 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
5690 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5691 Counter{cSubReqFromXapp, 1},
5692 Counter{cSubDelReqToE2, 1},
5693 Counter{cSubDelFailFromE2, 1},
5694 Counter{cSubRespToXapp, 1},
5699 var params *teststube2ap.RESTSubsReqParams = nil
5700 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
5701 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
5704 restSubId := xappConn1.SendRESTSubsReq(t, params)
5705 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
5707 // E2t: Receive SubsDelReq
5708 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5709 xappConn1.ExpectRESTNotification(t, restSubId)
5711 // Subscription does not exist in in E2 Node.
5712 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5714 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
5715 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
5717 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
5718 // Wait that subs is cleaned
5719 waitSubsCleanup(t, e2SubsId, 10)
5720 mainCtrl.VerifyCounterValues(t)
5723 ////////////////////////////////////////////////////////////////////////////////////
5724 // Services for UT cases
5725 ////////////////////////////////////////////////////////////////////////////////////
5726 const subReqCount int = 1
5727 const host string = "localhost"
5729 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
5731 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
5733 restSubId := fromXappConn.SendRESTSubsReq(t, params)
5734 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
5736 crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
5737 fromXappConn.ExpectRESTNotification(t, restSubId)
5738 toE2termConn.SendSubsResp(t, crereq1, cremsg1)
5739 e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
5740 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
5742 return restSubId, e2SubsId
5745 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
5747 params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
5749 params.SetMeid(meid)
5751 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
5752 restSubId := xappConn2.SendRESTSubsReq(t, params)
5753 xappConn2.ExpectRESTNotification(t, restSubId)
5754 xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
5755 e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
5756 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
5758 return restSubId, e2SubsId
5761 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
5762 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5763 restSubId := xappConn1.SendRESTSubsReq(t, params)
5764 xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
5766 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
5767 xappConn1.ExpectRESTNotification(t, restSubId)
5768 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
5769 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
5770 xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
5772 return restSubId, e2SubsId
5775 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
5776 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5777 restSubId := xappConn1.SendRESTSubsReq(t, params)
5779 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
5780 fparams1 := &teststube2ap.E2StubSubsFailParams{}
5781 fparams1.Set(crereq1)
5782 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
5784 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
5785 xappConn1.ExpectRESTNotification(t, restSubId)
5786 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
5787 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
5788 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
5790 return restSubId, e2SubsId
5793 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
5794 fromXappConn.SendRESTSubsDelReq(t, restSubId)
5795 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
5796 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
5799 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
5800 xappConn1.SendRESTSubsDelReq(t, restSubId)
5801 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5802 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5805 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
5806 xappConn2.SendRESTSubsDelReq(t, restSubId)
5807 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5808 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5811 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
5812 resp, _ := xapp.Subscription.QuerySubscriptions()
5813 assert.Equal(t, resp[0].SubscriptionID, e2SubsId)
5814 assert.Equal(t, resp[0].Meid, meid)
5815 assert.Equal(t, resp[0].ClientEndpoint, endpoint)
5818 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
5819 //Wait that subs is cleaned
5820 mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
5822 xappConn1.TestMsgChanEmpty(t)
5823 xappConn2.TestMsgChanEmpty(t)
5824 e2termConn1.TestMsgChanEmpty(t)
5825 mainCtrl.wait_registry_empty(t, timeout)
5828 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
5830 var e2SubsId []uint32
5832 for i := 0; i < count; i++ {
5833 xapp.Logger.Info("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
5834 crereq, cremsg := toE2termConn.RecvSubsReq(t)
5835 fromXappConn.ExpectRESTNotification(t, restSubId)
5836 toE2termConn.SendSubsResp(t, crereq, cremsg)
5837 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
5838 e2SubsId = append(e2SubsId, instanceId)
5839 xapp.Logger.Info("TEST: %v", e2SubsId)
5840 xapp.Logger.Info("TEST: %d ===================================== END CRE ============================================", i+1)
5841 <-time.After(100 * time.Millisecond)
5846 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
5848 for i := 0; i < len(e2SubsIds); i++ {
5849 xapp.Logger.Info("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
5850 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
5851 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
5852 <-time.After(1 * time.Second)
5853 xapp.Logger.Info("TEST: %d ===================================== END DEL ============================================", i+1)
5854 <-time.After(100 * time.Millisecond)
5857 // Wait that subs is cleaned
5858 for i := 0; i < len(e2SubsIds); i++ {
5859 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)