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:
118 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_RESP"] {
119 testError(t, "(%s) Received RIC_SUB_RESP wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_RESP", xapp.RicMessageTypeToName[msg.Mtype])
121 } else if msg.Xid != trans.xid {
122 testError(t, "(%s) Received RIC_SUB_RESP wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid)
125 packedData := &packer.PackedData{}
126 packedData.Buf = msg.Payload
128 unpackerr := e2SubsResp.UnPack(packedData)
130 if unpackerr != nil {
131 testError(t, "(%s) RIC_SUB_RESP unpack failed err: %s", xappConn.desc, unpackerr.Error())
133 geterr, resp := e2SubsResp.Get()
135 testError(t, "(%s) RIC_SUB_RESP get failed err: %s", xappConn.desc, geterr.Error())
138 xapp.Logger.Info("(%s) Recv Subs Resp rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.desc, msg.Xid, msg.SubId, resp.RequestId.Seq)
141 case <-time.After(15 * time.Second):
142 testError(t, "(%s) Not Received RIC_SUB_RESP within 15 secs", xappConn.desc)
148 //-----------------------------------------------------------------------------
150 //-----------------------------------------------------------------------------
151 func (xappConn *testingXappControl) handle_xapp_subs_fail(t *testing.T, trans *xappTransaction) int {
152 xapp.Logger.Info("(%s) handle_xapp_subs_fail", xappConn.desc)
153 e2SubsFail := e2asnpacker.NewPackerSubscriptionFailure()
156 //-------------------------------
157 // xapp activity: Recv Subs Fail
158 //-------------------------------
160 case msg := <-xappConn.rmrConChan:
161 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_FAILURE"] {
162 testError(t, "(%s) Received RIC_SUB_FAILURE wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_FAILURE", xapp.RicMessageTypeToName[msg.Mtype])
164 } else if msg.Xid != trans.xid {
165 testError(t, "(%s) Received RIC_SUB_FAILURE wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid)
168 packedData := &packer.PackedData{}
169 packedData.Buf = msg.Payload
171 unpackerr := e2SubsFail.UnPack(packedData)
173 if unpackerr != nil {
174 testError(t, "(%s) RIC_SUB_FAILURE unpack failed err: %s", xappConn.desc, unpackerr.Error())
176 geterr, resp := e2SubsFail.Get()
178 testError(t, "(%s) RIC_SUB_FAILURE get failed err: %s", xappConn.desc, geterr.Error())
181 xapp.Logger.Info("(%s) Recv Subs Fail rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.desc, msg.Xid, msg.SubId, resp.RequestId.Seq)
184 case <-time.After(15 * time.Second):
185 testError(t, "(%s) Not Received RIC_SUB_FAILURE within 15 secs", xappConn.desc)
191 //-----------------------------------------------------------------------------
193 //-----------------------------------------------------------------------------
194 func (xappConn *testingXappControl) handle_xapp_subs_del_req(t *testing.T, oldTrans *xappTransaction, e2SubsId int) *xappTransaction {
195 xapp.Logger.Info("(%s) handle_xapp_subs_del_req", xappConn.desc)
196 e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
198 //---------------------------------
199 // xapp activity: Send Subs Del Req
200 //---------------------------------
201 xapp.Logger.Info("(%s) Send Subs Del Req", xappConn.desc)
203 req := &e2ap.E2APSubscriptionDeleteRequest{}
205 req.RequestId.Seq = uint32(e2SubsId)
208 e2SubsDelReq.Set(req)
209 xapp.Logger.Debug("%s", e2SubsDelReq.String())
210 err, packedMsg := e2SubsDelReq.Pack(nil)
212 testError(t, "(%s) pack NOK %s", xappConn.desc, err.Error())
216 var trans *xappTransaction = oldTrans
218 trans = xappConn.newXappTransaction(nil, "RAN_NAME_1")
221 params := &RMRParams{&xapp.RMRParams{}}
222 params.Mtype = xapp.RIC_SUB_DEL_REQ
223 params.SubId = e2SubsId
224 params.Payload = packedMsg.Buf
225 params.Meid = trans.meid
226 params.Xid = trans.xid
229 snderr := xappConn.RmrSend(params)
231 testError(t, "(%s) RMR SEND FAILED: %s", xappConn.desc, snderr.Error())
237 //-----------------------------------------------------------------------------
239 //-----------------------------------------------------------------------------
240 func (xappConn *testingXappControl) handle_xapp_subs_del_resp(t *testing.T, trans *xappTransaction) {
241 xapp.Logger.Info("(%s) handle_xapp_subs_del_resp", xappConn.desc)
242 e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
244 //---------------------------------
245 // xapp activity: Recv Subs Del Resp
246 //---------------------------------
248 case msg := <-xappConn.rmrConChan:
249 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_RESP"] {
250 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])
252 } else if msg.Xid != trans.xid {
253 testError(t, "(%s) Received RIC_SUB_DEL_RESP wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid)
256 packedData := &packer.PackedData{}
257 packedData.Buf = msg.Payload
258 unpackerr := e2SubsDelResp.UnPack(packedData)
259 if unpackerr != nil {
260 testError(t, "(%s) RIC_SUB_DEL_RESP unpack failed err: %s", xappConn.desc, unpackerr.Error())
262 geterr, resp := e2SubsDelResp.Get()
264 testError(t, "(%s) RIC_SUB_DEL_RESP get failed err: %s", xappConn.desc, geterr.Error())
266 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)
269 case <-time.After(15 * time.Second):
270 testError(t, "(%s) Not Received RIC_SUB_DEL_RESP within 15 secs", xappConn.desc)
274 //-----------------------------------------------------------------------------
276 //-----------------------------------------------------------------------------
277 func (e2termConn *testingE2termControl) handle_e2term_subs_req(t *testing.T) (*e2ap.E2APSubscriptionRequest, *RMRParams) {
278 xapp.Logger.Info("(%s) handle_e2term_subs_req", e2termConn.desc)
279 e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest()
281 //---------------------------------
282 // e2term activity: Recv Subs Req
283 //---------------------------------
285 case msg := <-e2termConn.rmrConChan:
286 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_REQ"] {
287 testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.desc, "RIC_SUB_REQ", xapp.RicMessageTypeToName[msg.Mtype])
289 xapp.Logger.Info("(%s) Recv Subs Req", e2termConn.desc)
290 packedData := &packer.PackedData{}
291 packedData.Buf = msg.Payload
292 unpackerr := e2SubsReq.UnPack(packedData)
293 if unpackerr != nil {
294 testError(t, "(%s) RIC_SUB_REQ unpack failed err: %s", e2termConn.desc, unpackerr.Error())
296 geterr, req := e2SubsReq.Get()
298 testError(t, "(%s) RIC_SUB_REQ get failed err: %s", e2termConn.desc, geterr.Error())
302 case <-time.After(15 * time.Second):
303 testError(t, "(%s) Not Received RIC_SUB_REQ within 15 secs", e2termConn.desc)
308 func (e2termConn *testingE2termControl) handle_e2term_subs_resp(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *RMRParams) {
309 xapp.Logger.Info("(%s) handle_e2term_subs_resp", e2termConn.desc)
310 e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse()
312 //---------------------------------
313 // e2term activity: Send Subs Resp
314 //---------------------------------
315 xapp.Logger.Info("(%s) Send Subs Resp", e2termConn.desc)
317 resp := &e2ap.E2APSubscriptionResponse{}
319 resp.RequestId.Id = req.RequestId.Id
320 resp.RequestId.Seq = req.RequestId.Seq
321 resp.FunctionId = req.FunctionId
323 resp.ActionAdmittedList.Items = make([]e2ap.ActionAdmittedItem, len(req.ActionSetups))
324 for index := int(0); index < len(req.ActionSetups); index++ {
325 resp.ActionAdmittedList.Items[index].ActionId = req.ActionSetups[index].ActionId
328 for index := uint64(0); index < 1; index++ {
329 item := e2ap.ActionNotAdmittedItem{}
330 item.ActionId = index
331 item.Cause.Content = 1
332 item.Cause.CauseVal = 1
333 resp.ActionNotAdmittedList.Items = append(resp.ActionNotAdmittedList.Items, item)
337 xapp.Logger.Debug("%s", e2SubsResp.String())
338 packerr, packedMsg := e2SubsResp.Pack(nil)
340 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
343 params := &RMRParams{&xapp.RMRParams{}}
344 params.Mtype = xapp.RIC_SUB_RESP
345 params.SubId = msg.SubId
346 params.Payload = packedMsg.Buf
347 params.Meid = msg.Meid
351 snderr := e2termConn.RmrSend(params)
353 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
357 //-----------------------------------------------------------------------------
359 //-----------------------------------------------------------------------------
360 func (e2termConn *testingE2termControl) handle_e2term_subs_fail(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *RMRParams) {
361 xapp.Logger.Info("(%s) handle_e2term_subs_fail", e2termConn.desc)
362 e2SubsFail := e2asnpacker.NewPackerSubscriptionFailure()
364 //---------------------------------
365 // e2term activity: Send Subs Fail
366 //---------------------------------
367 xapp.Logger.Info("(%s) Send Subs Fail", e2termConn.desc)
369 resp := &e2ap.E2APSubscriptionFailure{}
370 resp.RequestId.Id = req.RequestId.Id
371 resp.RequestId.Seq = req.RequestId.Seq
372 resp.FunctionId = req.FunctionId
374 resp.ActionNotAdmittedList.Items = make([]e2ap.ActionNotAdmittedItem, len(resp.ActionNotAdmittedList.Items))
375 for index := int(0); index < len(resp.ActionNotAdmittedList.Items); index++ {
376 resp.ActionNotAdmittedList.Items[index].ActionId = req.ActionSetups[index].ActionId
377 resp.ActionNotAdmittedList.Items[index].Cause.Content = 3 // CauseMisc
378 resp.ActionNotAdmittedList.Items[index].Cause.CauseVal = 4 // unspecified
382 xapp.Logger.Debug("%s", e2SubsFail.String())
383 packerr, packedMsg := e2SubsFail.Pack(nil)
385 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
388 params := &RMRParams{&xapp.RMRParams{}}
389 params.Mtype = xapp.RIC_SUB_FAILURE
390 params.SubId = msg.SubId
391 params.Payload = packedMsg.Buf
392 params.Meid = msg.Meid
396 snderr := e2termConn.RmrSend(params)
398 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
402 //-----------------------------------------------------------------------------
404 //-----------------------------------------------------------------------------
405 func (e2termConn *testingE2termControl) handle_e2term_subs_del_req(t *testing.T) (*e2ap.E2APSubscriptionDeleteRequest, *RMRParams) {
406 xapp.Logger.Info("(%s) handle_e2term_subs_del_req", e2termConn.desc)
407 e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
409 //---------------------------------
410 // e2term activity: Recv Subs Del Req
411 //---------------------------------
413 case msg := <-e2termConn.rmrConChan:
414 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_REQ"] {
415 testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.desc, "RIC_SUB_DEL_REQ", xapp.RicMessageTypeToName[msg.Mtype])
417 xapp.Logger.Info("(%s) Recv Subs Del Req", e2termConn.desc)
419 packedData := &packer.PackedData{}
420 packedData.Buf = msg.Payload
421 unpackerr := e2SubsDelReq.UnPack(packedData)
422 if unpackerr != nil {
423 testError(t, "(%s) RIC_SUB_DEL_REQ unpack failed err: %s", e2termConn.desc, unpackerr.Error())
425 geterr, req := e2SubsDelReq.Get()
427 testError(t, "(%s) RIC_SUB_DEL_REQ get failed err: %s", e2termConn.desc, geterr.Error())
431 case <-time.After(15 * time.Second):
432 testError(t, "(%s) Not Received RIC_SUB_DEL_REQ within 15 secs", e2termConn.desc)
437 func handle_e2term_recv_empty() bool {
438 if len(e2termConn.rmrConChan) > 0 {
444 func (e2termConn *testingE2termControl) handle_e2term_subs_del_resp(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *RMRParams) {
445 xapp.Logger.Info("(%s) handle_e2term_subs_del_resp", e2termConn.desc)
446 e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
448 //---------------------------------
449 // e2term activity: Send Subs Del Resp
450 //---------------------------------
451 xapp.Logger.Info("(%s) Send Subs Del Resp", e2termConn.desc)
453 resp := &e2ap.E2APSubscriptionDeleteResponse{}
454 resp.RequestId.Id = req.RequestId.Id
455 resp.RequestId.Seq = req.RequestId.Seq
456 resp.FunctionId = req.FunctionId
458 e2SubsDelResp.Set(resp)
459 xapp.Logger.Debug("%s", e2SubsDelResp.String())
460 packerr, packedMsg := e2SubsDelResp.Pack(nil)
462 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
465 params := &RMRParams{&xapp.RMRParams{}}
466 params.Mtype = xapp.RIC_SUB_DEL_RESP
467 params.SubId = msg.SubId
468 params.Payload = packedMsg.Buf
469 params.Meid = msg.Meid
473 snderr := e2termConn.RmrSend(params)
475 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
479 //-----------------------------------------------------------------------------
481 //-----------------------------------------------------------------------------
482 func (e2termConn *testingE2termControl) handle_e2term_subs_del_fail(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *RMRParams) {
483 xapp.Logger.Info("(%s) handle_e2term_del_subs_fail", e2termConn.desc)
484 e2SubsDelFail := e2asnpacker.NewPackerSubscriptionDeleteFailure()
486 //---------------------------------
487 // e2term activity: Send Subs Del Fail
488 //---------------------------------
489 xapp.Logger.Info("(%s) Send Subs Del Fail", e2termConn.desc)
491 resp := &e2ap.E2APSubscriptionDeleteFailure{}
492 resp.RequestId.Id = req.RequestId.Id
493 resp.RequestId.Seq = req.RequestId.Seq
494 resp.FunctionId = req.FunctionId
495 resp.Cause.Content = 3 // CauseMisc
496 resp.Cause.CauseVal = 4 // unspecified
498 e2SubsDelFail.Set(resp)
499 xapp.Logger.Debug("%s", e2SubsDelFail.String())
500 packerr, packedMsg := e2SubsDelFail.Pack(nil)
502 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
505 params := &RMRParams{&xapp.RMRParams{}}
506 params.Mtype = xapp.RIC_SUB_DEL_FAILURE
507 params.SubId = msg.SubId
508 params.Payload = packedMsg.Buf
509 params.Meid = msg.Meid
513 snderr := e2termConn.RmrSend(params)
515 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
519 //-----------------------------------------------------------------------------
521 //-----------------------------------------------------------------------------
522 func (mc *testingMainControl) wait_subs_clean(t *testing.T, e2SubsId int, secs int) bool {
524 for ; i <= secs*2; i++ {
525 if mc.c.registry.GetSubscription(uint16(e2SubsId)) == nil {
528 time.Sleep(500 * time.Millisecond)
530 testError(t, "(general) no clean within %d secs", secs)
534 func (mc *testingMainControl) wait_subs_trans_clean(t *testing.T, e2SubsId int, secs int) bool {
536 for ; i <= secs*2; i++ {
537 subs := mc.c.registry.GetSubscription(uint16(e2SubsId))
541 trans := subs.GetTransaction()
545 time.Sleep(500 * time.Millisecond)
547 testError(t, "(general) no clean within %d secs", secs)
551 func (mc *testingMainControl) get_subid(t *testing.T) uint16 {
552 mc.c.registry.mutex.Lock()
553 defer mc.c.registry.mutex.Unlock()
554 return mc.c.registry.subIds[0]
557 func (mc *testingMainControl) wait_subid_change(t *testing.T, origSubId uint16, secs int) (uint16, bool) {
559 for ; i <= secs*2; i++ {
560 mc.c.registry.mutex.Lock()
561 currSubId := mc.c.registry.subIds[0]
562 mc.c.registry.mutex.Unlock()
563 if currSubId != origSubId {
564 return currSubId, true
566 time.Sleep(500 * time.Millisecond)
568 testError(t, "(general) no subId change within %d secs", secs)
572 func (mc *testingMainControl) get_msgcounter(t *testing.T) uint64 {
573 return mc.c.msgCounter
576 func (mc *testingMainControl) wait_msgcounter_change(t *testing.T, orig uint64, secs int) (uint64, bool) {
578 for ; i <= secs*2; i++ {
579 curr := mc.c.msgCounter
583 time.Sleep(500 * time.Millisecond)
585 testError(t, "(general) no msg counter change within %d secs", secs)
589 //-----------------------------------------------------------------------------
590 // TestSubReqAndRouteNok
593 // +-------+ +---------+ +---------+
594 // | xapp | | submgr | | rtmgr |
595 // +-------+ +---------+ +---------+
598 // |------------->| |
601 // | |------------->|
605 // | |<-------------|
607 // | [SUBS INT DELETE] |
610 //-----------------------------------------------------------------------------
612 func TestSubReqAndRouteNok(t *testing.T) {
613 xapp.Logger.Info("TestSubReqAndRouteNok")
615 waiter := rtmgrHttp.AllocNextEvent(false)
616 newSubsId := mainCtrl.get_subid(t)
617 xappConn1.handle_xapp_subs_req(t, nil)
620 //Wait that subs is cleaned
621 mainCtrl.wait_subs_clean(t, int(newSubsId), 10)
624 //-----------------------------------------------------------------------------
625 // TestSubReqAndSubDelOk
628 // +-------+ +---------+ +---------+
629 // | xapp | | submgr | | e2term |
630 // +-------+ +---------+ +---------+
633 // |------------->| |
636 // | |------------->|
639 // | |<-------------|
642 // |<-------------| |
646 // |------------->| |
649 // | |------------->|
652 // | |<-------------|
655 // |<-------------| |
657 //-----------------------------------------------------------------------------
658 func TestSubReqAndSubDelOk(t *testing.T) {
659 xapp.Logger.Info("TestSubReqAndSubDelOk")
661 waiter := rtmgrHttp.AllocNextEvent(true)
662 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
665 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
666 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
667 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
668 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
669 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
671 waiter = rtmgrHttp.AllocNextEvent(true)
672 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
673 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
676 //Wait that subs is cleaned
677 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
680 //-----------------------------------------------------------------------------
681 // TestSubReqRetransmission
684 // +-------+ +---------+ +---------+
685 // | xapp | | submgr | | e2term |
686 // +-------+ +---------+ +---------+
689 // |------------->| |
692 // | |------------->|
696 // |------------->| |
699 // | |<-------------|
702 // |<-------------| |
707 //-----------------------------------------------------------------------------
708 func TestSubReqRetransmission(t *testing.T) {
709 xapp.Logger.Info("TestSubReqRetransmission")
712 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
713 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
715 seqBef := mainCtrl.get_msgcounter(t)
716 xappConn1.handle_xapp_subs_req(t, cretrans) //Retransmitted SubReq
717 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
719 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
720 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
723 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
724 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
725 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
726 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
728 //Wait that subs is cleaned
729 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
732 //-----------------------------------------------------------------------------
733 // TestSubDelReqRetransmission
736 // +-------+ +---------+ +---------+
737 // | xapp | | submgr | | e2term |
738 // +-------+ +---------+ +---------+
744 // |------------->| |
747 // | |------------->|
752 // |------------->| |
755 // | |<-------------|
758 // |<-------------| |
760 //-----------------------------------------------------------------------------
761 func TestSubDelReqRetransmission(t *testing.T) {
762 xapp.Logger.Info("TestSubDelReqRetransmission")
765 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
766 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
767 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
768 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
771 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
772 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
774 seqBef := mainCtrl.get_msgcounter(t)
775 xappConn1.handle_xapp_subs_del_req(t, deltrans, e2SubsId) //Retransmitted SubDelReq
776 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
778 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
779 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
781 //Wait that subs is cleaned
782 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
785 //-----------------------------------------------------------------------------
786 // TestSubDelReqCollision
789 // +-------+ +---------+ +---------+
790 // | xapp | | submgr | | e2term |
791 // +-------+ +---------+ +---------+
797 // |------------->| |
800 // | |------------->|
805 // |------------->| |
808 // | |<-------------|
811 // |<-------------| |
813 //-----------------------------------------------------------------------------
814 func TestSubDelReqCollision(t *testing.T) {
815 xapp.Logger.Info("TestSubDelReqCollision")
818 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
819 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
820 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
821 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
824 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
825 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
827 seqBef := mainCtrl.get_msgcounter(t)
828 deltranscol := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
829 xappConn1.handle_xapp_subs_del_req(t, deltranscol, e2SubsId) //Colliding SubDelReq
830 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
832 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
833 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
835 //Wait that subs is cleaned
836 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
839 //-----------------------------------------------------------------------------
840 // TestSubReqAndSubDelOkTwoParallel
843 // +-------+ +---------+ +---------+
844 // | xapp | | submgr | | e2term |
845 // +-------+ +---------+ +---------+
850 // |------------->| |
853 // | |------------->|
856 // |------------->| |
859 // | |------------->|
862 // | |<-------------|
864 // | |<-------------|
867 // |<-------------| |
869 // |<-------------| |
871 // | [SUBS 1 DELETE] |
873 // | [SUBS 2 DELETE] |
876 //-----------------------------------------------------------------------------
877 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
878 xapp.Logger.Info("TestSubReqAndSubDelOkTwoParallel")
881 cretrans1 := xappConn1.handle_xapp_subs_req(t, nil)
882 crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t)
885 cretrans2 := xappConn2.handle_xapp_subs_req(t, nil)
886 crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t)
889 e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1)
890 e2SubsId1 := xappConn1.handle_xapp_subs_resp(t, cretrans1)
893 e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2)
894 e2SubsId2 := xappConn2.handle_xapp_subs_resp(t, cretrans2)
897 deltrans1 := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId1)
898 delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t)
899 e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1)
900 xappConn1.handle_xapp_subs_del_resp(t, deltrans1)
901 //Wait that subs is cleaned
902 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
905 deltrans2 := xappConn2.handle_xapp_subs_del_req(t, nil, e2SubsId2)
906 delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t)
907 e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2)
908 xappConn2.handle_xapp_subs_del_resp(t, deltrans2)
909 //Wait that subs is cleaned
910 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
913 //-----------------------------------------------------------------------------
914 // TestSameSubsDiffRan
915 // Same subscription to different RANs
918 // +-------+ +---------+ +---------+
919 // | xapp | | submgr | | e2term |
920 // +-------+ +---------+ +---------+
925 // |------------->| |
928 // | |------------->|
931 // | |<-------------|
934 // |<-------------| |
937 // |------------->| |
940 // | |------------->|
943 // | |<-------------|
946 // |<-------------| |
948 // | [SUBS r1 DELETE] |
950 // | [SUBS r2 DELETE] |
953 //-----------------------------------------------------------------------------
954 func TestSameSubsDiffRan(t *testing.T) {
955 xapp.Logger.Info("TestSameSubsDiffRan")
958 cretrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
959 xappConn1.handle_xapp_subs_req(t, cretrans1)
960 crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t)
961 e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1)
962 e2SubsId1 := xappConn1.handle_xapp_subs_resp(t, cretrans1)
965 cretrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2")
966 xappConn1.handle_xapp_subs_req(t, cretrans2)
967 crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t)
968 e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2)
969 e2SubsId2 := xappConn1.handle_xapp_subs_resp(t, cretrans2)
972 deltrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
973 xappConn1.handle_xapp_subs_del_req(t, deltrans1, e2SubsId1)
974 delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t)
975 e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1)
976 xappConn1.handle_xapp_subs_del_resp(t, deltrans1)
977 //Wait that subs is cleaned
978 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
981 deltrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2")
982 xappConn1.handle_xapp_subs_del_req(t, deltrans2, e2SubsId2)
983 delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t)
984 e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2)
985 xappConn1.handle_xapp_subs_del_resp(t, deltrans2)
986 //Wait that subs is cleaned
987 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
990 //-----------------------------------------------------------------------------
991 // TestSubReqRetryInSubmgr
994 // +-------+ +---------+ +---------+
995 // | xapp | | submgr | | e2term |
996 // +-------+ +---------+ +---------+
999 // |------------->| |
1002 // | |------------->|
1006 // | |------------->|
1009 // | |<-------------|
1012 // |<-------------| |
1014 // | [SUBS DELETE] |
1017 //-----------------------------------------------------------------------------
1019 func TestSubReqRetryInSubmgr(t *testing.T) {
1021 xapp.Logger.Info("TestSubReqRetryInSubmgr start")
1023 // Xapp: Send SubsReq
1024 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1026 // E2t: Receive 1st SubsReq
1027 e2termConn.handle_e2term_subs_req(t)
1029 // E2t: Receive 2nd SubsReq and send SubsResp
1030 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1031 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1033 // Xapp: Receive SubsResp
1034 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1036 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1037 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1038 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
1039 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1041 // Wait that subs is cleaned
1042 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1045 //-----------------------------------------------------------------------------
1046 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
1049 // +-------+ +---------+ +---------+
1050 // | xapp | | submgr | | e2term |
1051 // +-------+ +---------+ +---------+
1054 // |------------->| |
1057 // | |------------->|
1061 // | |------------->|
1064 // | |------------->|
1068 // | |------------->|
1072 // | |<-------------|
1075 //-----------------------------------------------------------------------------
1077 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
1079 xapp.Logger.Info("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
1081 // Xapp: Send SubsReq
1082 xappConn1.handle_xapp_subs_req(t, nil)
1084 // E2t: Receive 1st SubsReq
1085 e2termConn.handle_e2term_subs_req(t)
1087 // E2t: Receive 2nd SubsReq
1088 e2termConn.handle_e2term_subs_req(t)
1090 // E2t: Send receive SubsDelReq and send SubsResp
1091 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1092 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
1094 // Wait that subs is cleaned
1095 mainCtrl.wait_subs_clean(t, int(delreq.RequestId.Seq), 10)
1098 //-----------------------------------------------------------------------------
1099 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
1102 // +-------+ +---------+ +---------+
1103 // | xapp | | submgr | | e2term |
1104 // +-------+ +---------+ +---------+
1107 // |------------->| |
1110 // | |------------->|
1114 // | |------------->|
1117 // | |------------->|
1121 // | |------------->|
1125 //-----------------------------------------------------------------------------
1127 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
1129 xapp.Logger.Info("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
1131 // Xapp: Send SubsReq
1132 xappConn1.handle_xapp_subs_req(t, nil)
1134 // E2t: Receive 1st SubsReq
1135 e2termConn.handle_e2term_subs_req(t)
1137 // E2t: Receive 2nd SubsReq
1138 e2termConn.handle_e2term_subs_req(t)
1140 // E2t: Receive 1st SubsDelReq
1141 e2termConn.handle_e2term_subs_del_req(t)
1143 // E2t: Receive 2nd SubsDelReq
1144 delreq, _ := e2termConn.handle_e2term_subs_del_req(t)
1146 // Wait that subs is cleaned
1147 mainCtrl.wait_subs_clean(t, int(delreq.RequestId.Seq), 10)
1150 //-----------------------------------------------------------------------------
1151 // TestSubReqSubFailRespInSubmgr
1154 // +-------+ +---------+ +---------+
1155 // | xapp | | submgr | | e2term |
1156 // +-------+ +---------+ +---------+
1159 // |------------->| |
1162 // | |------------->|
1165 // | |<-------------|
1168 // |<-------------| |
1171 //-----------------------------------------------------------------------------
1173 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1175 xapp.Logger.Info("TestSubReqSubFailRespInSubmgr start")
1177 // Xapp: Send SubsReq
1178 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1180 // E2t: Receive SubsReq and send SubsFail
1181 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1182 e2termConn.handle_e2term_subs_fail(t, crereq, cremsg)
1184 // Xapp: Receive SubsFail
1185 e2SubsId := xappConn1.handle_xapp_subs_fail(t, cretrans)
1187 // Wait that subs is cleaned
1188 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1191 //-----------------------------------------------------------------------------
1192 // TestSubDelReqRetryInSubmgr
1195 // +-------+ +---------+ +---------+
1196 // | xapp | | submgr | | e2term |
1197 // +-------+ +---------+ +---------+
1199 // | [SUBS CREATE] |
1203 // |------------->| |
1206 // | |------------->|
1209 // | |------------->|
1212 // | |<-------------|
1215 // |<-------------| |
1217 //-----------------------------------------------------------------------------
1219 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1221 xapp.Logger.Info("TestSubDelReqRetryInSubmgr start")
1224 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1225 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1226 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1227 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1230 // Xapp: Send SubsDelReq
1231 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1233 // E2t: Receive 1st SubsDelReq
1234 e2termConn.handle_e2term_subs_del_req(t)
1236 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1237 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1238 e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
1240 // Xapp: Receive SubsDelResp
1241 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1243 // Wait that subs is cleaned
1244 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1247 //-----------------------------------------------------------------------------
1248 // TestSubDelReqTwoRetriesNoRespInSubmgr
1251 // +-------+ +---------+ +---------+
1252 // | xapp | | submgr | | e2term |
1253 // +-------+ +---------+ +---------+
1255 // | [SUBS CREATE] |
1259 // |------------->| |
1262 // | |------------->|
1265 // | |------------->|
1269 // |<-------------| |
1271 //-----------------------------------------------------------------------------
1273 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1275 xapp.Logger.Info("TestSubDelReTwoRetriesNoRespInSubmgr start")
1278 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1279 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1280 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1281 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1284 // Xapp: Send SubsDelReq
1285 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1287 // E2t: Receive 1st SubsDelReq
1288 e2termConn.handle_e2term_subs_del_req(t)
1290 // E2t: Receive 2nd SubsDelReq
1291 e2termConn.handle_e2term_subs_del_req(t)
1293 // Xapp: Receive SubsDelResp
1294 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1296 // Wait that subs is cleaned
1297 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1300 //-----------------------------------------------------------------------------
1301 // TestSubDelReqSubDelFailRespInSubmgr
1304 // +-------+ +---------+ +---------+
1305 // | xapp | | submgr | | e2term |
1306 // +-------+ +---------+ +---------+
1308 // | [SUBS CREATE] |
1312 // |------------->| |
1315 // | |------------->|
1318 // | |<-------------|
1321 // |<-------------| |
1324 //-----------------------------------------------------------------------------
1326 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1328 xapp.Logger.Info("TestSubReqSubDelFailRespInSubmgr start")
1331 cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1332 crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1333 e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1334 e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1336 // Xapp: Send SubsDelReq
1337 deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1339 // E2t: Send receive SubsDelReq and send SubsDelFail
1340 delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1341 e2termConn.handle_e2term_subs_del_fail(t, delreq, delmsg)
1343 // Xapp: Receive SubsDelResp
1344 xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1346 // Wait that subs is cleaned
1347 mainCtrl.wait_subs_clean(t, e2SubsId, 10)