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 ==================================================================================
23 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
24 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper"
25 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/packer"
26 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
31 //-----------------------------------------------------------------------------
33 //-----------------------------------------------------------------------------
34 var e2asnpacker e2ap.E2APPackerIf = e2ap_wrapper.NewAsn1E2Packer()
36 //-----------------------------------------------------------------------------
38 //-----------------------------------------------------------------------------
39 func (xappConn *testingXappControl) handle_xapp_subs_req(t *testing.T, oldTrans *xappTransaction) *xappTransaction {
40 xapp.Logger.Info("(%s) handle_xapp_subs_req", xappConn.desc)
41 e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest()
43 //---------------------------------
44 // xapp activity: Send Subs Req
45 //---------------------------------
46 xapp.Logger.Info("(%s) Send Subs Req", xappConn.desc)
48 req := &e2ap.E2APSubscriptionRequest{}
54 req.EventTriggerDefinition.InterfaceId.GlobalEnbId.Present = true
55 req.EventTriggerDefinition.InterfaceId.GlobalEnbId.PlmnIdentity.StringPut("310150")
56 req.EventTriggerDefinition.InterfaceId.GlobalEnbId.NodeId.Id = 123
57 req.EventTriggerDefinition.InterfaceId.GlobalEnbId.NodeId.Bits = e2ap.E2AP_ENBIDHomeBits28
59 // gnb -> enb outgoing
60 // enb -> gnb incoming
62 req.EventTriggerDefinition.InterfaceDirection = e2ap.E2AP_InterfaceDirectionIncoming
63 req.EventTriggerDefinition.ProcedureCode = 5 //28 35
64 req.EventTriggerDefinition.TypeOfMessage = e2ap.E2AP_InitiatingMessage
66 req.ActionSetups = make([]e2ap.ActionToBeSetupItem, 1)
67 req.ActionSetups[0].ActionId = 0
68 req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeReport
69 req.ActionSetups[0].ActionDefinition.Present = false
70 //req.ActionSetups[index].ActionDefinition.StyleId = 255
71 //req.ActionSetups[index].ActionDefinition.ParamId = 222
72 req.ActionSetups[0].SubsequentAction.Present = true
73 req.ActionSetups[0].SubsequentAction.Type = e2ap.E2AP_SubSeqActionTypeContinue
74 req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitZero
77 xapp.Logger.Debug("%s", e2SubsReq.String())
78 err, packedMsg := e2SubsReq.Pack(nil)
80 testError(t, "(%s) pack NOK %s", xappConn.desc, err.Error())
84 var trans *xappTransaction = oldTrans
86 trans = xappConn.newXappTransaction(nil, "RAN_NAME_1")
89 params := &RMRParams{&xapp.RMRParams{}}
90 params.Mtype = xapp.RIC_SUB_REQ
92 params.Payload = packedMsg.Buf
93 params.Meid = trans.meid
94 params.Xid = trans.xid
97 snderr := xappConn.RmrSend(params)
99 testError(t, "(%s) RMR SEND FAILED: %s", xappConn.desc, snderr.Error())
105 //-----------------------------------------------------------------------------
107 //-----------------------------------------------------------------------------
108 func (xappConn *testingXappControl) handle_xapp_subs_resp(t *testing.T, trans *xappTransaction) int {
109 xapp.Logger.Info("(%s) handle_xapp_subs_resp", xappConn.desc)
110 e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse()
113 //---------------------------------
114 // xapp activity: Recv Subs Resp
115 //---------------------------------
117 case msg := <-xappConn.rmrConChan:
119 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_RESP"] {
120 testError(t, "(%s) Received RIC_SUB_RESP wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_RESP", xapp.RicMessageTypeToName[msg.Mtype])
122 } else if msg.Xid != trans.xid {
123 testError(t, "(%s) Received RIC_SUB_RESP wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid)
126 packedData := &packer.PackedData{}
127 packedData.Buf = msg.Payload
129 unpackerr := e2SubsResp.UnPack(packedData)
131 if unpackerr != nil {
132 testError(t, "(%s) RIC_SUB_RESP unpack failed err: %s", xappConn.desc, unpackerr.Error())
134 geterr, resp := e2SubsResp.Get()
136 testError(t, "(%s) RIC_SUB_RESP get failed err: %s", xappConn.desc, geterr.Error())
139 xapp.Logger.Info("(%s) Recv Subs Resp rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.desc, msg.Xid, msg.SubId, resp.RequestId.Seq)
142 case <-time.After(15 * time.Second):
143 testError(t, "(%s) Not Received RIC_SUB_RESP within 15 secs", xappConn.desc)
149 //-----------------------------------------------------------------------------
151 //-----------------------------------------------------------------------------
152 func (xappConn *testingXappControl) handle_xapp_subs_fail(t *testing.T, trans *xappTransaction) int {
153 xapp.Logger.Info("(%s) handle_xapp_subs_fail", xappConn.desc)
154 e2SubsFail := e2asnpacker.NewPackerSubscriptionFailure()
157 //-------------------------------
158 // xapp activity: Recv Subs Fail
159 //-------------------------------
161 case msg := <-xappConn.rmrConChan:
163 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_FAILURE"] {
164 testError(t, "(%s) Received RIC_SUB_FAILURE wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_FAILURE", xapp.RicMessageTypeToName[msg.Mtype])
166 } else if msg.Xid != trans.xid {
167 testError(t, "(%s) Received RIC_SUB_FAILURE wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid)
170 packedData := &packer.PackedData{}
171 packedData.Buf = msg.Payload
173 unpackerr := e2SubsFail.UnPack(packedData)
175 if unpackerr != nil {
176 testError(t, "(%s) RIC_SUB_FAILURE unpack failed err: %s", xappConn.desc, unpackerr.Error())
178 geterr, resp := e2SubsFail.Get()
180 testError(t, "(%s) RIC_SUB_FAILURE get failed err: %s", xappConn.desc, geterr.Error())
183 xapp.Logger.Info("(%s) Recv Subs Fail rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.desc, msg.Xid, msg.SubId, resp.RequestId.Seq)
186 case <-time.After(15 * time.Second):
187 testError(t, "(%s) Not Received RIC_SUB_FAILURE within 15 secs", xappConn.desc)
193 //-----------------------------------------------------------------------------
195 //-----------------------------------------------------------------------------
196 func (xappConn *testingXappControl) handle_xapp_subs_del_req(t *testing.T, oldTrans *xappTransaction, e2SubsId int) *xappTransaction {
197 xapp.Logger.Info("(%s) handle_xapp_subs_del_req", xappConn.desc)
198 e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
200 //---------------------------------
201 // xapp activity: Send Subs Del Req
202 //---------------------------------
203 xapp.Logger.Info("(%s) Send Subs Del Req", xappConn.desc)
205 req := &e2ap.E2APSubscriptionDeleteRequest{}
207 req.RequestId.Seq = uint32(e2SubsId)
210 e2SubsDelReq.Set(req)
211 xapp.Logger.Debug("%s", e2SubsDelReq.String())
212 err, packedMsg := e2SubsDelReq.Pack(nil)
214 testError(t, "(%s) pack NOK %s", xappConn.desc, err.Error())
218 var trans *xappTransaction = oldTrans
220 trans = xappConn.newXappTransaction(nil, "RAN_NAME_1")
223 params := &RMRParams{&xapp.RMRParams{}}
224 params.Mtype = xapp.RIC_SUB_DEL_REQ
225 params.SubId = e2SubsId
226 params.Payload = packedMsg.Buf
227 params.Meid = trans.meid
228 params.Xid = trans.xid
231 snderr := xappConn.RmrSend(params)
233 testError(t, "(%s) RMR SEND FAILED: %s", xappConn.desc, snderr.Error())
239 //-----------------------------------------------------------------------------
241 //-----------------------------------------------------------------------------
242 func (xappConn *testingXappControl) handle_xapp_subs_del_resp(t *testing.T, trans *xappTransaction) {
243 xapp.Logger.Info("(%s) handle_xapp_subs_del_resp", xappConn.desc)
244 e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
246 //---------------------------------
247 // xapp activity: Recv Subs Del Resp
248 //---------------------------------
250 case msg := <-xappConn.rmrConChan:
252 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_RESP"] {
253 testError(t, "(%s) Received RIC_SUB_DEL_RESP wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_DEL_RESP", xapp.RicMessageTypeToName[msg.Mtype])
255 } else if msg.Xid != trans.xid {
256 testError(t, "(%s) Received RIC_SUB_DEL_RESP wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid)
259 packedData := &packer.PackedData{}
260 packedData.Buf = msg.Payload
261 unpackerr := e2SubsDelResp.UnPack(packedData)
262 if unpackerr != nil {
263 testError(t, "(%s) RIC_SUB_DEL_RESP unpack failed err: %s", xappConn.desc, unpackerr.Error())
265 geterr, resp := e2SubsDelResp.Get()
267 testError(t, "(%s) RIC_SUB_DEL_RESP get failed err: %s", xappConn.desc, geterr.Error())
269 xapp.Logger.Info("(%s) Recv Subs Del Resp rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.desc, msg.Xid, msg.SubId, resp.RequestId.Seq)
272 case <-time.After(15 * time.Second):
273 testError(t, "(%s) Not Received RIC_SUB_DEL_RESP within 15 secs", xappConn.desc)
277 //-----------------------------------------------------------------------------
279 //-----------------------------------------------------------------------------
280 func (e2termConn *testingE2termControl) handle_e2term_subs_req(t *testing.T) (*e2ap.E2APSubscriptionRequest, *RMRParams) {
281 xapp.Logger.Info("(%s) handle_e2term_subs_req", e2termConn.desc)
282 e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest()
284 //---------------------------------
285 // e2term activity: Recv Subs Req
286 //---------------------------------
288 case msg := <-e2termConn.rmrConChan:
289 e2termConn.DecMsgCnt()
290 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_REQ"] {
291 testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.desc, "RIC_SUB_REQ", xapp.RicMessageTypeToName[msg.Mtype])
293 xapp.Logger.Info("(%s) Recv Subs Req", e2termConn.desc)
294 packedData := &packer.PackedData{}
295 packedData.Buf = msg.Payload
296 unpackerr := e2SubsReq.UnPack(packedData)
297 if unpackerr != nil {
298 testError(t, "(%s) RIC_SUB_REQ unpack failed err: %s", e2termConn.desc, unpackerr.Error())
300 geterr, req := e2SubsReq.Get()
302 testError(t, "(%s) RIC_SUB_REQ get failed err: %s", e2termConn.desc, geterr.Error())
306 case <-time.After(15 * time.Second):
307 testError(t, "(%s) Not Received RIC_SUB_REQ within 15 secs", e2termConn.desc)
312 func (e2termConn *testingE2termControl) handle_e2term_subs_resp(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *RMRParams) {
313 xapp.Logger.Info("(%s) handle_e2term_subs_resp", e2termConn.desc)
314 e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse()
316 //---------------------------------
317 // e2term activity: Send Subs Resp
318 //---------------------------------
319 xapp.Logger.Info("(%s) Send Subs Resp", e2termConn.desc)
321 resp := &e2ap.E2APSubscriptionResponse{}
323 resp.RequestId.Id = req.RequestId.Id
324 resp.RequestId.Seq = req.RequestId.Seq
325 resp.FunctionId = req.FunctionId
327 resp.ActionAdmittedList.Items = make([]e2ap.ActionAdmittedItem, len(req.ActionSetups))
328 for index := int(0); index < len(req.ActionSetups); index++ {
329 resp.ActionAdmittedList.Items[index].ActionId = req.ActionSetups[index].ActionId
332 for index := uint64(0); index < 1; index++ {
333 item := e2ap.ActionNotAdmittedItem{}
334 item.ActionId = index
335 item.Cause.Content = 1
336 item.Cause.CauseVal = 1
337 resp.ActionNotAdmittedList.Items = append(resp.ActionNotAdmittedList.Items, item)
341 xapp.Logger.Debug("%s", e2SubsResp.String())
342 packerr, packedMsg := e2SubsResp.Pack(nil)
344 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
347 params := &RMRParams{&xapp.RMRParams{}}
348 params.Mtype = xapp.RIC_SUB_RESP
349 //params.SubId = msg.SubId
351 params.Payload = packedMsg.Buf
352 params.Meid = msg.Meid
353 //params.Xid = msg.Xid
356 snderr := e2termConn.RmrSend(params)
358 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
362 //-----------------------------------------------------------------------------
364 //-----------------------------------------------------------------------------
365 func (e2termConn *testingE2termControl) handle_e2term_subs_fail(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *RMRParams) {
366 xapp.Logger.Info("(%s) handle_e2term_subs_fail", e2termConn.desc)
367 e2SubsFail := e2asnpacker.NewPackerSubscriptionFailure()
369 //---------------------------------
370 // e2term activity: Send Subs Fail
371 //---------------------------------
372 xapp.Logger.Info("(%s) Send Subs Fail", e2termConn.desc)
374 resp := &e2ap.E2APSubscriptionFailure{}
375 resp.RequestId.Id = req.RequestId.Id
376 resp.RequestId.Seq = req.RequestId.Seq
377 resp.FunctionId = req.FunctionId
379 resp.ActionNotAdmittedList.Items = make([]e2ap.ActionNotAdmittedItem, len(resp.ActionNotAdmittedList.Items))
380 for index := int(0); index < len(resp.ActionNotAdmittedList.Items); index++ {
381 resp.ActionNotAdmittedList.Items[index].ActionId = req.ActionSetups[index].ActionId
382 resp.ActionNotAdmittedList.Items[index].Cause.Content = 3 // CauseMisc
383 resp.ActionNotAdmittedList.Items[index].Cause.CauseVal = 4 // unspecified
387 xapp.Logger.Debug("%s", e2SubsFail.String())
388 packerr, packedMsg := e2SubsFail.Pack(nil)
390 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
393 params := &RMRParams{&xapp.RMRParams{}}
394 params.Mtype = xapp.RIC_SUB_FAILURE
395 params.SubId = msg.SubId
396 params.Payload = packedMsg.Buf
397 params.Meid = msg.Meid
401 snderr := e2termConn.RmrSend(params)
403 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
407 //-----------------------------------------------------------------------------
409 //-----------------------------------------------------------------------------
410 func (e2termConn *testingE2termControl) handle_e2term_subs_del_req(t *testing.T) (*e2ap.E2APSubscriptionDeleteRequest, *RMRParams) {
411 xapp.Logger.Info("(%s) handle_e2term_subs_del_req", e2termConn.desc)
412 e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
414 //---------------------------------
415 // e2term activity: Recv Subs Del Req
416 //---------------------------------
418 case msg := <-e2termConn.rmrConChan:
419 e2termConn.DecMsgCnt()
420 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_REQ"] {
421 testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.desc, "RIC_SUB_DEL_REQ", xapp.RicMessageTypeToName[msg.Mtype])
423 xapp.Logger.Info("(%s) Recv Subs Del Req", e2termConn.desc)
425 packedData := &packer.PackedData{}
426 packedData.Buf = msg.Payload
427 unpackerr := e2SubsDelReq.UnPack(packedData)
428 if unpackerr != nil {
429 testError(t, "(%s) RIC_SUB_DEL_REQ unpack failed err: %s", e2termConn.desc, unpackerr.Error())
431 geterr, req := e2SubsDelReq.Get()
433 testError(t, "(%s) RIC_SUB_DEL_REQ get failed err: %s", e2termConn.desc, geterr.Error())
437 case <-time.After(15 * time.Second):
438 testError(t, "(%s) Not Received RIC_SUB_DEL_REQ within 15 secs", e2termConn.desc)
443 func handle_e2term_recv_empty() bool {
444 if len(e2termConn.rmrConChan) > 0 {
450 func (e2termConn *testingE2termControl) handle_e2term_subs_del_resp(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *RMRParams) {
451 xapp.Logger.Info("(%s) handle_e2term_subs_del_resp", e2termConn.desc)
452 e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
454 //---------------------------------
455 // e2term activity: Send Subs Del Resp
456 //---------------------------------
457 xapp.Logger.Info("(%s) Send Subs Del Resp", e2termConn.desc)
459 resp := &e2ap.E2APSubscriptionDeleteResponse{}
460 resp.RequestId.Id = req.RequestId.Id
461 resp.RequestId.Seq = req.RequestId.Seq
462 resp.FunctionId = req.FunctionId
464 e2SubsDelResp.Set(resp)
465 xapp.Logger.Debug("%s", e2SubsDelResp.String())
466 packerr, packedMsg := e2SubsDelResp.Pack(nil)
468 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
471 params := &RMRParams{&xapp.RMRParams{}}
472 params.Mtype = xapp.RIC_SUB_DEL_RESP
473 params.SubId = msg.SubId
474 params.Payload = packedMsg.Buf
475 params.Meid = msg.Meid
479 snderr := e2termConn.RmrSend(params)
481 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
485 //-----------------------------------------------------------------------------
487 //-----------------------------------------------------------------------------
488 func (e2termConn *testingE2termControl) handle_e2term_subs_del_fail(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *RMRParams) {
489 xapp.Logger.Info("(%s) handle_e2term_del_subs_fail", e2termConn.desc)
490 e2SubsDelFail := e2asnpacker.NewPackerSubscriptionDeleteFailure()
492 //---------------------------------
493 // e2term activity: Send Subs Del Fail
494 //---------------------------------
495 xapp.Logger.Info("(%s) Send Subs Del Fail", e2termConn.desc)
497 resp := &e2ap.E2APSubscriptionDeleteFailure{}
498 resp.RequestId.Id = req.RequestId.Id
499 resp.RequestId.Seq = req.RequestId.Seq
500 resp.FunctionId = req.FunctionId
501 resp.Cause.Content = 3 // CauseMisc
502 resp.Cause.CauseVal = 4 // unspecified
504 e2SubsDelFail.Set(resp)
505 xapp.Logger.Debug("%s", e2SubsDelFail.String())
506 packerr, packedMsg := e2SubsDelFail.Pack(nil)
508 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
511 params := &RMRParams{&xapp.RMRParams{}}
512 params.Mtype = xapp.RIC_SUB_DEL_FAILURE
513 params.SubId = msg.SubId
514 params.Payload = packedMsg.Buf
515 params.Meid = msg.Meid
519 snderr := e2termConn.RmrSend(params)
521 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
525 //-----------------------------------------------------------------------------
527 //-----------------------------------------------------------------------------
528 func (mc *testingMainControl) wait_subs_clean(t *testing.T, e2SubsId int, secs int) bool {
529 var subs *Subscription
531 for ; i <= secs*2; i++ {
532 subs = mc.c.registry.GetSubscription(uint16(e2SubsId))
536 time.Sleep(500 * time.Millisecond)
539 testError(t, "(general) no clean within %d secs: %s", secs, subs.String())
541 testError(t, "(general) no clean within %d secs: subs(N/A)", secs)
546 func (mc *testingMainControl) wait_subs_trans_clean(t *testing.T, e2SubsId int, secs int) bool {
547 var trans *Transaction
549 for ; i <= secs*2; i++ {
550 subs := mc.c.registry.GetSubscription(uint16(e2SubsId))
554 trans = subs.GetTransaction()
558 time.Sleep(500 * time.Millisecond)
561 testError(t, "(general) no clean within %d secs: %s", secs, trans.String())
563 testError(t, "(general) no clean within %d secs: trans(N/A)", secs)
568 func (mc *testingMainControl) get_subid(t *testing.T) uint16 {
569 mc.c.registry.mutex.Lock()
570 defer mc.c.registry.mutex.Unlock()
571 return mc.c.registry.subIds[0]
574 func (mc *testingMainControl) wait_subid_change(t *testing.T, origSubId uint16, secs int) (uint16, bool) {
576 for ; i <= secs*2; i++ {
577 mc.c.registry.mutex.Lock()
578 currSubId := mc.c.registry.subIds[0]
579 mc.c.registry.mutex.Unlock()
580 if currSubId != origSubId {
581 return currSubId, true
583 time.Sleep(500 * time.Millisecond)
585 testError(t, "(general) no subId change within %d secs", secs)
589 func (mc *testingMainControl) get_msgcounter(t *testing.T) uint64 {
590 return mc.c.msgCounter
593 func (mc *testingMainControl) wait_msgcounter_change(t *testing.T, orig uint64, secs int) (uint64, bool) {
595 for ; i <= secs*2; i++ {
596 curr := mc.c.msgCounter
600 time.Sleep(500 * time.Millisecond)
602 testError(t, "(general) no msg counter change within %d secs", secs)
606 //-----------------------------------------------------------------------------
607 // TestSubReqAndRouteNok
610 // +-------+ +---------+ +---------+
611 // | xapp | | submgr | | rtmgr |
612 // +-------+ +---------+ +---------+
615 // |------------->| |
618 // | |------------->|
622 // | |<-------------|
624 // | [SUBS INT DELETE] |
627 //-----------------------------------------------------------------------------
629 func TestSubReqAndRouteNok(t *testing.T) {
630 xapp.Logger.Info("TestSubReqAndRouteNok")
632 waiter := rtmgrHttp.AllocNextEvent(false)
633 newSubsId := mainCtrl.get_subid(t)
634 xappConn1.handle_xapp_subs_req(t, nil)
637 //Wait that subs is cleaned
638 mainCtrl.wait_subs_clean(t, int(newSubsId), 10)
640 xappConn1.TestMsgCnt(t)
641 xappConn2.TestMsgCnt(t)
642 e2termConn.TestMsgCnt(t)
645 //-----------------------------------------------------------------------------
646 // TestSubReqAndSubDelOk
649 // +-------+ +---------+ +---------+
650 // | xapp | | submgr | | e2term |
651 // +-------+ +---------+ +---------+
654 // |------------->| |
657 // | |------------->|
660 // | |<-------------|
663 // |<-------------| |
667 // |------------->| |
670 // | |------------->|
673 // | |<-------------|
676 // |<-------------| |
678 //-----------------------------------------------------------------------------
679 func TestSubReqAndSubDelOk(t *testing.T) {
680 xapp.Logger.Info("TestSubReqAndSubDelOk")
682 waiter := rtmgrHttp.AllocNextEvent(true)
683 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
686 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
687 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
688 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
689 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
690 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
692 waiter = rtmgrHttp.AllocNextEvent(true)
693 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
694 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
697 //Wait that subs is cleaned
698 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
700 xappConn1.TestMsgCnt(t)
701 xappConn2.TestMsgCnt(t)
702 e2termConn.TestMsgCnt(t)
705 //-----------------------------------------------------------------------------
706 // TestSubReqRetransmission
709 // +-------+ +---------+ +---------+
710 // | xapp | | submgr | | e2term |
711 // +-------+ +---------+ +---------+
714 // |------------->| |
717 // | |------------->|
721 // |------------->| |
724 // | |<-------------|
727 // |<-------------| |
732 //-----------------------------------------------------------------------------
733 func TestSubReqRetransmission(t *testing.T) {
734 xapp.Logger.Info("TestSubReqRetransmission")
737 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
738 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
740 seqBef := mainCtrl.get_msgcounter(t)
741 xappConn1.handle_xapp_subs_req(t, cretrans) //Retransmitted SubReq
742 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
744 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
745 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
748 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
749 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
750 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
751 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
753 //Wait that subs is cleaned
754 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
756 xappConn1.TestMsgCnt(t)
757 xappConn2.TestMsgCnt(t)
758 e2termConn.TestMsgCnt(t)
761 //-----------------------------------------------------------------------------
762 // TestSubDelReqRetransmission
765 // +-------+ +---------+ +---------+
766 // | xapp | | submgr | | e2term |
767 // +-------+ +---------+ +---------+
773 // |------------->| |
776 // | |------------->|
781 // |------------->| |
784 // | |<-------------|
787 // |<-------------| |
789 //-----------------------------------------------------------------------------
790 func TestSubDelReqRetransmission(t *testing.T) {
791 xapp.Logger.Info("TestSubDelReqRetransmission")
794 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
795 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
796 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
797 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
800 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
801 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
803 seqBef := mainCtrl.get_msgcounter(t)
804 xappConn1.handle_xapp_subs_del_req(t, deltrans, e2SubsId) //Retransmitted SubDelReq
805 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
807 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
808 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
810 //Wait that subs is cleaned
811 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
813 xappConn1.TestMsgCnt(t)
814 xappConn2.TestMsgCnt(t)
815 e2termConn.TestMsgCnt(t)
818 //-----------------------------------------------------------------------------
819 // TestSubDelReqCollision
822 // +-------+ +---------+ +---------+
823 // | xapp | | submgr | | e2term |
824 // +-------+ +---------+ +---------+
830 // |------------->| |
833 // | |------------->|
838 // |------------->| |
841 // | |<-------------|
844 // |<-------------| |
846 //-----------------------------------------------------------------------------
847 func TestSubDelReqCollision(t *testing.T) {
848 xapp.Logger.Info("TestSubDelReqCollision")
851 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
852 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
853 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
854 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
857 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
858 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
860 seqBef := mainCtrl.get_msgcounter(t)
861 deltranscol := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
862 xappConn1.handle_xapp_subs_del_req(t, deltranscol, e2SubsId) //Colliding SubDelReq
863 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
865 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
866 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
868 //Wait that subs is cleaned
869 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
871 xappConn1.TestMsgCnt(t)
872 xappConn2.TestMsgCnt(t)
873 e2termConn.TestMsgCnt(t)
876 //-----------------------------------------------------------------------------
877 // TestSubReqAndSubDelOkTwoParallel
880 // +-------+ +---------+ +---------+
881 // | xapp | | submgr | | e2term |
882 // +-------+ +---------+ +---------+
887 // |------------->| |
890 // | |------------->|
893 // |------------->| |
896 // | |------------->|
899 // | |<-------------|
901 // | |<-------------|
904 // |<-------------| |
906 // |<-------------| |
908 // | [SUBS 1 DELETE] |
910 // | [SUBS 2 DELETE] |
913 //-----------------------------------------------------------------------------
914 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
915 xapp.Logger.Info("TestSubReqAndSubDelOkTwoParallel")
918 cretrans1 := xappConn1.handle_xapp_subs_req(t, nil)
919 crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t)
922 cretrans2 := xappConn2.handle_xapp_subs_req(t, nil)
923 crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t)
926 e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1)
927 e2SubsId1 := xappConn1.handle_xapp_subs_resp(t, cretrans1)
930 e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2)
931 e2SubsId2 := xappConn2.handle_xapp_subs_resp(t, cretrans2)
934 deltrans1 := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId1)
935 delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t)
936 e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1)
937 xappConn1.handle_xapp_subs_del_resp(t, deltrans1)
938 //Wait that subs is cleaned
939 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
942 deltrans2 := xappConn2.handle_xapp_subs_del_req(t, nil, e2SubsId2)
943 delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t)
944 e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2)
945 xappConn2.handle_xapp_subs_del_resp(t, deltrans2)
946 //Wait that subs is cleaned
947 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
949 xappConn1.TestMsgCnt(t)
950 xappConn2.TestMsgCnt(t)
951 e2termConn.TestMsgCnt(t)
954 //-----------------------------------------------------------------------------
955 // TestSameSubsDiffRan
956 // Same subscription to different RANs
959 // +-------+ +---------+ +---------+
960 // | xapp | | submgr | | e2term |
961 // +-------+ +---------+ +---------+
966 // |------------->| |
969 // | |------------->|
972 // | |<-------------|
975 // |<-------------| |
978 // |------------->| |
981 // | |------------->|
984 // | |<-------------|
987 // |<-------------| |
989 // | [SUBS r1 DELETE] |
991 // | [SUBS r2 DELETE] |
994 //-----------------------------------------------------------------------------
995 func TestSameSubsDiffRan(t *testing.T) {
996 xapp.Logger.Info("TestSameSubsDiffRan")
999 cretrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
1000 xappConn1.handle_xapp_subs_req(t, cretrans1)
1001 crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t)
1002 e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1)
1003 e2SubsId1 := xappConn1.handle_xapp_subs_resp(t, cretrans1)
1006 cretrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2")
1007 xappConn1.handle_xapp_subs_req(t, cretrans2)
1008 crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t)
1009 e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2)
1010 e2SubsId2 := xappConn1.handle_xapp_subs_resp(t, cretrans2)
1013 deltrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
1014 xappConn1.handle_xapp_subs_del_req(t, deltrans1, e2SubsId1)
1015 delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t)
1016 e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1)
1017 xappConn1.handle_xapp_subs_del_resp(t, deltrans1)
1018 //Wait that subs is cleaned
1019 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1022 deltrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2")
1023 xappConn1.handle_xapp_subs_del_req(t, deltrans2, e2SubsId2)
1024 delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t)
1025 e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2)
1026 xappConn1.handle_xapp_subs_del_resp(t, deltrans2)
1027 //Wait that subs is cleaned
1028 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1030 xappConn1.TestMsgCnt(t)
1031 xappConn2.TestMsgCnt(t)
1032 e2termConn.TestMsgCnt(t)
1035 //-----------------------------------------------------------------------------
1036 // TestSubReqRetryInSubmgr
1039 // +-------+ +---------+ +---------+
1040 // | xapp | | submgr | | e2term |
1041 // +-------+ +---------+ +---------+
1044 // |------------->| |
1047 // | |------------->|
1051 // | |------------->|
1054 // | |<-------------|
1057 // |<-------------| |
1059 // | [SUBS DELETE] |
1062 //-----------------------------------------------------------------------------
1064 func TestSubReqRetryInSubmgr(t *testing.T) {
1066 xapp.Logger.Info("TestSubReqRetryInSubmgr start")
1068 // Xapp: Send SubsReq
1069 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1071 // E2t: Receive 1st SubsReq
1072 e2termConn.handle_e2term_subs_req(t)
1074 // E2t: Receive 2nd SubsReq and send SubsResp
1075 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1076 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1078 // Xapp: Receive SubsResp
1079 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1081 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1082 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1083 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
1084 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1086 // Wait that subs is cleaned
1087 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1089 xappConn1.TestMsgCnt(t)
1090 xappConn2.TestMsgCnt(t)
1091 e2termConn.TestMsgCnt(t)
1094 //-----------------------------------------------------------------------------
1095 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
1098 // +-------+ +---------+ +---------+
1099 // | xapp | | submgr | | e2term |
1100 // +-------+ +---------+ +---------+
1103 // |------------->| |
1106 // | |------------->|
1110 // | |------------->|
1113 // | |------------->|
1117 // | |------------->|
1121 // | |<-------------|
1124 //-----------------------------------------------------------------------------
1126 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
1128 xapp.Logger.Info("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
1130 // Xapp: Send SubsReq
1131 xappConn1.handle_xapp_subs_req(t, nil)
1133 // E2t: Receive 1st SubsReq
1134 e2termConn.handle_e2term_subs_req(t)
1136 // E2t: Receive 2nd SubsReq
1137 e2termConn.handle_e2term_subs_req(t)
1139 // E2t: Send receive SubsDelReq and send SubsResp
1140 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1141 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
1143 // Wait that subs is cleaned
1144 mainCtrl.wait_subs_clean(t, int(delreq.RequestId.Seq), 10)
1146 xappConn1.TestMsgCnt(t)
1147 xappConn2.TestMsgCnt(t)
1148 e2termConn.TestMsgCnt(t)
1151 //-----------------------------------------------------------------------------
1152 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
1155 // +-------+ +---------+ +---------+
1156 // | xapp | | submgr | | e2term |
1157 // +-------+ +---------+ +---------+
1160 // |------------->| |
1163 // | |------------->|
1167 // | |------------->|
1170 // | |------------->|
1174 // | |------------->|
1178 //-----------------------------------------------------------------------------
1180 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
1182 xapp.Logger.Info("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
1184 // Xapp: Send SubsReq
1185 xappConn1.handle_xapp_subs_req(t, nil)
1187 // E2t: Receive 1st SubsReq
1188 e2termConn.handle_e2term_subs_req(t)
1190 // E2t: Receive 2nd SubsReq
1191 e2termConn.handle_e2term_subs_req(t)
1193 // E2t: Receive 1st SubsDelReq
1194 e2termConn.handle_e2term_subs_del_req(t)
1196 // E2t: Receive 2nd SubsDelReq
1197 delreq, _ := e2termConn.handle_e2term_subs_del_req(t)
1199 // Wait that subs is cleaned
1200 mainCtrl.wait_subs_clean(t, int(delreq.RequestId.Seq), 15)
1202 xappConn1.TestMsgCnt(t)
1203 xappConn2.TestMsgCnt(t)
1204 e2termConn.TestMsgCnt(t)
1207 //-----------------------------------------------------------------------------
1208 // TestSubReqSubFailRespInSubmgr
1211 // +-------+ +---------+ +---------+
1212 // | xapp | | submgr | | e2term |
1213 // +-------+ +---------+ +---------+
1216 // |------------->| |
1219 // | |------------->|
1222 // | |<-------------|
1225 // |<-------------| |
1228 //-----------------------------------------------------------------------------
1230 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1232 xapp.Logger.Info("TestSubReqSubFailRespInSubmgr start")
1234 // Xapp: Send SubsReq
1235 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1237 // E2t: Receive SubsReq and send SubsFail
1238 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1239 e2termConn.handle_e2term_subs_fail(t, crereq, cremsg)
1241 // Xapp: Receive SubsFail
1242 e2SubsId := xappConn1.handle_xapp_subs_fail(t, cretrans)
1244 // Wait that subs is cleaned
1245 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1247 xappConn1.TestMsgCnt(t)
1248 xappConn2.TestMsgCnt(t)
1249 e2termConn.TestMsgCnt(t)
1252 //-----------------------------------------------------------------------------
1253 // TestSubDelReqRetryInSubmgr
1256 // +-------+ +---------+ +---------+
1257 // | xapp | | submgr | | e2term |
1258 // +-------+ +---------+ +---------+
1260 // | [SUBS CREATE] |
1264 // |------------->| |
1267 // | |------------->|
1270 // | |------------->|
1273 // | |<-------------|
1276 // |<-------------| |
1278 //-----------------------------------------------------------------------------
1280 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1282 xapp.Logger.Info("TestSubDelReqRetryInSubmgr start")
1285 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1286 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1287 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1288 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1291 // Xapp: Send SubsDelReq
1292 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1294 // E2t: Receive 1st SubsDelReq
1295 e2termConn.handle_e2term_subs_del_req(t)
1297 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1298 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1299 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
1301 // Xapp: Receive SubsDelResp
1302 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1304 // Wait that subs is cleaned
1305 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1307 xappConn1.TestMsgCnt(t)
1308 xappConn2.TestMsgCnt(t)
1309 e2termConn.TestMsgCnt(t)
1312 //-----------------------------------------------------------------------------
1313 // TestSubDelReqTwoRetriesNoRespInSubmgr
1316 // +-------+ +---------+ +---------+
1317 // | xapp | | submgr | | e2term |
1318 // +-------+ +---------+ +---------+
1320 // | [SUBS CREATE] |
1324 // |------------->| |
1327 // | |------------->|
1330 // | |------------->|
1334 // |<-------------| |
1336 //-----------------------------------------------------------------------------
1338 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1340 xapp.Logger.Info("TestSubDelReTwoRetriesNoRespInSubmgr start")
1343 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1344 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1345 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1346 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1349 // Xapp: Send SubsDelReq
1350 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1352 // E2t: Receive 1st SubsDelReq
1353 e2termConn.handle_e2term_subs_del_req(t)
1355 // E2t: Receive 2nd SubsDelReq
1356 e2termConn.handle_e2term_subs_del_req(t)
1358 // Xapp: Receive SubsDelResp
1359 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1361 // Wait that subs is cleaned
1362 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1364 xappConn1.TestMsgCnt(t)
1365 xappConn2.TestMsgCnt(t)
1366 e2termConn.TestMsgCnt(t)
1369 //-----------------------------------------------------------------------------
1370 // TestSubDelReqSubDelFailRespInSubmgr
1373 // +-------+ +---------+ +---------+
1374 // | xapp | | submgr | | e2term |
1375 // +-------+ +---------+ +---------+
1377 // | [SUBS CREATE] |
1381 // |------------->| |
1384 // | |------------->|
1387 // | |<-------------|
1390 // |<-------------| |
1393 //-----------------------------------------------------------------------------
1395 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1397 xapp.Logger.Info("TestSubReqSubDelFailRespInSubmgr start")
1400 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1401 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1402 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1403 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1405 // Xapp: Send SubsDelReq
1406 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1408 // E2t: Send receive SubsDelReq and send SubsDelFail
1409 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1410 e2termConn.handle_e2term_subs_del_fail(t, delreq, delmsg)
1412 // Xapp: Receive SubsDelResp
1413 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1415 // Wait that subs is cleaned
1416 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1418 xappConn1.TestMsgCnt(t)
1419 xappConn2.TestMsgCnt(t)
1420 e2termConn.TestMsgCnt(t)