X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=pkg%2Fcontrol%2Fmessaging_test.go;h=b8ed6e6296d18713bb1559407e6c6fdd197cbbf4;hb=bf2f4122f6bf89fc572f6c4cad5f0c4108a996e0;hp=730856389b6863efb566c57eda2021b712af0fe4;hpb=4abd13267e35a67201b650112eb859e47d8f8d77;p=ric-plt%2Fsubmgr.git diff --git a/pkg/control/messaging_test.go b/pkg/control/messaging_test.go index 7308563..b8ed6e6 100644 --- a/pkg/control/messaging_test.go +++ b/pkg/control/messaging_test.go @@ -37,7 +37,29 @@ var e2asnpacker e2ap.E2APPackerIf = e2ap_wrapper.NewAsn1E2Packer() //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- -func createSubsReq() *e2ap.E2APSubscriptionRequest { +type xappTransaction struct { + xappConn *testingXappControl + xid string +} + +func newXappTransaction(xappConn *testingXappControl) { + trans := &xappTransaction{} + trans.xappConn = xappConn + trans.xid = xappConn.newXid() +} + +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- +func (xappConn *testingXappControl) handle_xapp_subs_req(t *testing.T, updseq bool) { + xapp.Logger.Info("handle_xapp_subs_req") + e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest() + + //--------------------------------- + // xapp activity: Send Subs Req + //--------------------------------- + xapp.Logger.Info("(%s) Send Subs Req", xappConn.desc) + req := &e2ap.E2APSubscriptionRequest{} req.RequestId.Id = 1 @@ -66,242 +88,233 @@ func createSubsReq() *e2ap.E2APSubscriptionRequest { req.ActionSetups[0].SubsequentAction.Type = e2ap.E2AP_SubSeqActionTypeContinue req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitZero - return req -} - -//----------------------------------------------------------------------------- -// -//----------------------------------------------------------------------------- -func createSubsResp(req *e2ap.E2APSubscriptionRequest) *e2ap.E2APSubscriptionResponse { - - resp := &e2ap.E2APSubscriptionResponse{} - - resp.RequestId.Id = req.RequestId.Id - resp.RequestId.Seq = req.RequestId.Seq - resp.FunctionId = req.FunctionId - - resp.ActionAdmittedList.Items = make([]e2ap.ActionAdmittedItem, len(req.ActionSetups)) - for index := int(0); index < len(req.ActionSetups); index++ { - resp.ActionAdmittedList.Items[index].ActionId = req.ActionSetups[index].ActionId - } - - for index := uint64(0); index < 1; index++ { - item := e2ap.ActionNotAdmittedItem{} - item.ActionId = index - item.Cause.Content = 1 - item.Cause.CauseVal = 1 - resp.ActionNotAdmittedList.Items = append(resp.ActionNotAdmittedList.Items, item) - } - - return resp -} - -//----------------------------------------------------------------------------- -// -//----------------------------------------------------------------------------- -func createSubsDelReq(e2SubsId uint32) *e2ap.E2APSubscriptionDeleteRequest { - req := &e2ap.E2APSubscriptionDeleteRequest{} - req.RequestId.Id = 1 - req.RequestId.Seq = e2SubsId - req.FunctionId = 1 - return req -} - -//----------------------------------------------------------------------------- -// -//----------------------------------------------------------------------------- -func createSubsDelResp(req *e2ap.E2APSubscriptionDeleteRequest) *e2ap.E2APSubscriptionDeleteResponse { - resp := &e2ap.E2APSubscriptionDeleteResponse{} - resp.RequestId.Id = req.RequestId.Id - resp.RequestId.Seq = req.RequestId.Seq - resp.FunctionId = req.FunctionId - return resp -} - -//----------------------------------------------------------------------------- -// -//----------------------------------------------------------------------------- -func handle_xapp_subs_req(t *testing.T) { - xapp.Logger.Info("handle_xapp_subs_req start") - e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest() - - //--------------------------------- - // xapp activity: Send Subs Req - //--------------------------------- - //select { - //case <-time.After(1 * time.Second): - xapp.Logger.Info("(xappConn) Send Subs Req") - req := createSubsReq() e2SubsReq.Set(req) xapp.Logger.Debug("%s", e2SubsReq.String()) err, packedMsg := e2SubsReq.Pack(nil) if err != nil { - testError(t, "(xappConn) pack NOK %s", err.Error()) + testError(t, "(%s) pack NOK %s", xappConn.desc, err.Error()) } params := &xapp.RMRParams{} params.Mtype = xapp.RIC_SUB_REQ params.SubId = -1 params.Payload = packedMsg.Buf - params.Meid = &xapp.RMRMeid{RanName: "RAN_NAME_1"} - params.Xid = "XID_1" + params.Meid = xappConn.meid + if updseq { + xappConn.newXid() + } + params.Xid = xappConn.xid params.Mbuf = nil snderr := xappConn.RmrSend(params) if snderr != nil { - testError(t, "(xappConn) RMR SEND FAILED: %s", snderr.Error()) + testError(t, "(%s) RMR SEND FAILED: %s", xappConn.desc, snderr.Error()) } - //} } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- -func handle_e2term_subs_req(t *testing.T) (*e2ap.E2APSubscriptionRequest, *xapp.RMRParams) { - xapp.Logger.Info("handle_e2term_subs_req start") - e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest() +func (xappConn *testingXappControl) handle_xapp_subs_resp(t *testing.T) int { + xapp.Logger.Info("handle_xapp_subs_resp") + e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse() + var e2SubsId int //--------------------------------- - // e2term activity: Recv Subs Req + // xapp activity: Recv Subs Resp //--------------------------------- select { - case msg := <-e2termConn.rmrConChan: - if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_REQ"] { - testError(t, "(e2termConn) Received non RIC_SUB_REQ message") + case msg := <-xappConn.rmrConChan: + if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_RESP"] { + testError(t, "(%s) Received wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_RESP", xapp.RicMessageTypeToName[msg.Mtype]) + return -1 } else { - xapp.Logger.Info("(e2termConn) Recv Subs Req") packedData := &packer.PackedData{} packedData.Buf = msg.Payload - unpackerr := e2SubsReq.UnPack(packedData) + e2SubsId = msg.SubId + unpackerr := e2SubsResp.UnPack(packedData) + if unpackerr != nil { - testError(t, "(e2termConn) RIC_SUB_REQ unpack failed err: %s", unpackerr.Error()) + testError(t, "(%s) RIC_SUB_RESP unpack failed err: %s", xappConn.desc, unpackerr.Error()) } - geterr, req := e2SubsReq.Get() + geterr, resp := e2SubsResp.Get() if geterr != nil { - testError(t, "(e2termConn) RIC_SUB_REQ get failed err: %s", geterr.Error()) + testError(t, "(%s) RIC_SUB_RESP get failed err: %s", xappConn.desc, geterr.Error()) } - return req, msg + + xapp.Logger.Info("(%s) Recv Subs Resp rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.desc, msg.Xid, msg.SubId, resp.RequestId.Seq) + return e2SubsId } case <-time.After(15 * time.Second): - testError(t, "(e2termConn) Not Received RIC_SUB_REQ within 15 secs") + testError(t, "(%s) Not Received RIC_SUB_RESP within 15 secs", xappConn.desc) + return -1 } - return nil, nil + return -1 } -func handle_e2term_subs_resp(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *xapp.RMRParams) { - xapp.Logger.Info("handle_e2term_subs_resp start") - e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse() +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- +func (xappConn *testingXappControl) handle_xapp_subs_del_req(t *testing.T, updseq bool, e2SubsId int) { + xapp.Logger.Info("handle_xapp_subs_del_req") + e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest() //--------------------------------- - // e2term activity: Send Subs Resp + // xapp activity: Send Subs Del Req //--------------------------------- - xapp.Logger.Info("(e2termConn) Send Subs Resp") - resp := createSubsResp(req) - e2SubsResp.Set(resp) - xapp.Logger.Debug("%s", e2SubsResp.String()) - packerr, packedMsg := e2SubsResp.Pack(nil) - if packerr != nil { - testError(t, "(e2termConn) pack NOK %s", packerr.Error()) + xapp.Logger.Info("(%s) Send Subs Del Req", xappConn.desc) + + req := &e2ap.E2APSubscriptionDeleteRequest{} + req.RequestId.Id = 1 + req.RequestId.Seq = uint32(e2SubsId) + req.FunctionId = 1 + + e2SubsDelReq.Set(req) + xapp.Logger.Debug("%s", e2SubsDelReq.String()) + err, packedMsg := e2SubsDelReq.Pack(nil) + if err != nil { + testError(t, "(%s) pack NOK %s", xappConn.desc, err.Error()) } params := &xapp.RMRParams{} - params.Mtype = xapp.RIC_SUB_RESP - params.SubId = msg.SubId + params.Mtype = xapp.RIC_SUB_DEL_REQ + params.SubId = e2SubsId params.Payload = packedMsg.Buf - params.Meid = msg.Meid - params.Xid = msg.Xid + params.Meid = xappConn.meid + if updseq { + xappConn.newXid() + } + params.Xid = xappConn.xid params.Mbuf = nil - snderr := e2termConn.RmrSend(params) + snderr := xappConn.RmrSend(params) if snderr != nil { - testError(t, "(e2termConn) RMR SEND FAILED: %s", snderr.Error()) + testError(t, "(%s) RMR SEND FAILED: %s", xappConn.desc, snderr.Error()) } } -func handle_e2term_subs_reqandresp(t *testing.T) { - req, msg := handle_e2term_subs_req(t) - handle_e2term_subs_resp(t, req, msg) -} - //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- -func handle_xapp_subs_resp(t *testing.T) int { - xapp.Logger.Info("handle_xapp_subs_resp start") - e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse() - var e2SubsId int +func (xappConn *testingXappControl) handle_xapp_subs_del_resp(t *testing.T) { + xapp.Logger.Info("handle_xapp_subs_del_resp") + e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse() //--------------------------------- - // xapp activity: Recv Subs Resp + // xapp activity: Recv Subs Del Resp //--------------------------------- select { case msg := <-xappConn.rmrConChan: - if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_RESP"] { - testError(t, "(xappConn) Received non RIC_SUB_RESP message") + if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_RESP"] { + testError(t, "(%s) Received wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_DEL_RESP", xapp.RicMessageTypeToName[msg.Mtype]) + return } else { - xapp.Logger.Info("(xappConn) Recv Subs Resp") - packedData := &packer.PackedData{} packedData.Buf = msg.Payload - e2SubsId = msg.SubId - unpackerr := e2SubsResp.UnPack(packedData) - + unpackerr := e2SubsDelResp.UnPack(packedData) if unpackerr != nil { - testError(t, "(xappConn) RIC_SUB_RESP unpack failed err: %s", unpackerr.Error()) + testError(t, "(%s) RIC_SUB_DEL_RESP unpack failed err: %s", xappConn.desc, unpackerr.Error()) } - geterr, _ := e2SubsResp.Get() + geterr, resp := e2SubsDelResp.Get() if geterr != nil { - testError(t, "(xappConn) RIC_SUB_RESP get failed err: %s", geterr.Error()) + testError(t, "(%s) RIC_SUB_DEL_RESP get failed err: %s", xappConn.desc, geterr.Error()) } - + 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) + return } case <-time.After(15 * time.Second): - testError(t, "(xappConn) Not Received RIC_SUB_RESP within 15 secs") + testError(t, "(%s) Not Received RIC_SUB_DEL_RESP within 15 secs", xappConn.desc) } - return e2SubsId } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- -func handle_xapp_subs_del_req(t *testing.T, e2SubsId int) { - xapp.Logger.Info("handle_xapp_subs_del_req start") - e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest() +func (e2termConn *testingE2termControl) handle_e2term_subs_req(t *testing.T) (*e2ap.E2APSubscriptionRequest, *xapp.RMRParams) { + xapp.Logger.Info("handle_e2term_subs_req") + e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest() //--------------------------------- - // xapp activity: Send Subs Del Req + // e2term activity: Recv Subs Req //--------------------------------- - //select { - //case <-time.After(1 * time.Second): - xapp.Logger.Info("(xappConn) Send Subs Del Req") - req := createSubsDelReq(uint32(e2SubsId)) - e2SubsDelReq.Set(req) - xapp.Logger.Debug("%s", e2SubsDelReq.String()) - err, packedMsg := e2SubsDelReq.Pack(nil) - if err != nil { - testError(t, "(xappConn) pack NOK %s", err.Error()) + select { + case msg := <-e2termConn.rmrConChan: + if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_REQ"] { + testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.desc, "RIC_SUB_REQ", xapp.RicMessageTypeToName[msg.Mtype]) + } else { + xapp.Logger.Info("(%s) Recv Subs Req", e2termConn.desc) + packedData := &packer.PackedData{} + packedData.Buf = msg.Payload + unpackerr := e2SubsReq.UnPack(packedData) + if unpackerr != nil { + testError(t, "(%s) RIC_SUB_REQ unpack failed err: %s", e2termConn.desc, unpackerr.Error()) + } + geterr, req := e2SubsReq.Get() + if geterr != nil { + testError(t, "(%s) RIC_SUB_REQ get failed err: %s", e2termConn.desc, geterr.Error()) + } + return req, msg + } + case <-time.After(15 * time.Second): + testError(t, "(%s) Not Received RIC_SUB_REQ within 15 secs", e2termConn.desc) + } + return nil, nil +} + +func (e2termConn *testingE2termControl) handle_e2term_subs_resp(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *xapp.RMRParams) { + xapp.Logger.Info("handle_e2term_subs_resp") + e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse() + + //--------------------------------- + // e2term activity: Send Subs Resp + //--------------------------------- + xapp.Logger.Info("(%s) Send Subs Resp", e2termConn.desc) + + resp := &e2ap.E2APSubscriptionResponse{} + + resp.RequestId.Id = req.RequestId.Id + resp.RequestId.Seq = req.RequestId.Seq + resp.FunctionId = req.FunctionId + + resp.ActionAdmittedList.Items = make([]e2ap.ActionAdmittedItem, len(req.ActionSetups)) + for index := int(0); index < len(req.ActionSetups); index++ { + resp.ActionAdmittedList.Items[index].ActionId = req.ActionSetups[index].ActionId + } + + for index := uint64(0); index < 1; index++ { + item := e2ap.ActionNotAdmittedItem{} + item.ActionId = index + item.Cause.Content = 1 + item.Cause.CauseVal = 1 + resp.ActionNotAdmittedList.Items = append(resp.ActionNotAdmittedList.Items, item) + } + + e2SubsResp.Set(resp) + xapp.Logger.Debug("%s", e2SubsResp.String()) + packerr, packedMsg := e2SubsResp.Pack(nil) + if packerr != nil { + testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error()) } params := &xapp.RMRParams{} - params.Mtype = xapp.RIC_SUB_DEL_REQ - params.SubId = e2SubsId + params.Mtype = xapp.RIC_SUB_RESP + params.SubId = msg.SubId params.Payload = packedMsg.Buf - params.Meid = &xapp.RMRMeid{RanName: "RAN_NAME_1"} - params.Xid = "XID_1" + params.Meid = msg.Meid + params.Xid = msg.Xid params.Mbuf = nil - snderr := xappConn.RmrSend(params) + snderr := e2termConn.RmrSend(params) if snderr != nil { - testError(t, "(xappConn) RMR SEND FAILED: %s", snderr.Error()) + testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error()) } - //} } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- -func handle_e2term_subs_del_req(t *testing.T) (*e2ap.E2APSubscriptionDeleteRequest, *xapp.RMRParams) { - xapp.Logger.Info("handle_e2term_subs_del_req start") +func (e2termConn *testingE2termControl) handle_e2term_subs_del_req(t *testing.T) (*e2ap.E2APSubscriptionDeleteRequest, *xapp.RMRParams) { + xapp.Logger.Info("handle_e2term_subs_del_req") e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest() //--------------------------------- @@ -310,42 +323,54 @@ func handle_e2term_subs_del_req(t *testing.T) (*e2ap.E2APSubscriptionDeleteReque select { case msg := <-e2termConn.rmrConChan: if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_REQ"] { - testError(t, "(e2termConn) Received non RIC_SUB_DEL_REQ message") + testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.desc, "RIC_SUB_DEL_REQ", xapp.RicMessageTypeToName[msg.Mtype]) } else { - xapp.Logger.Info("(e2termConn) Recv Subs Del Req") + xapp.Logger.Info("(%s) Recv Subs Del Req", e2termConn.desc) packedData := &packer.PackedData{} packedData.Buf = msg.Payload unpackerr := e2SubsDelReq.UnPack(packedData) if unpackerr != nil { - testError(t, "(e2termConn) RIC_SUB_DEL_REQ unpack failed err: %s", unpackerr.Error()) + testError(t, "(%s) RIC_SUB_DEL_REQ unpack failed err: %s", e2termConn.desc, unpackerr.Error()) } geterr, req := e2SubsDelReq.Get() if geterr != nil { - testError(t, "(e2termConn) RIC_SUB_DEL_REQ get failed err: %s", geterr.Error()) + testError(t, "(%s) RIC_SUB_DEL_REQ get failed err: %s", e2termConn.desc, geterr.Error()) } return req, msg } case <-time.After(15 * time.Second): - testError(t, "(e2termConn) Not Received RIC_SUB_DEL_REQ within 15 secs") + testError(t, "(%s) Not Received RIC_SUB_DEL_REQ within 15 secs", e2termConn.desc) } return nil, nil } -func handle_e2term_subs_del_resp(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *xapp.RMRParams) { - xapp.Logger.Info("handle_e2term_subs_del_resp start") +func handle_e2term_recv_empty() bool { + if len(e2termConn.rmrConChan) > 0 { + return false + } + return true +} + +func (e2termConn *testingE2termControl) handle_e2term_subs_del_resp(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *xapp.RMRParams) { + xapp.Logger.Info("handle_e2term_subs_del_resp") e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse() //--------------------------------- // e2term activity: Send Subs Del Resp //--------------------------------- - xapp.Logger.Info("(e2termConn) Send Subs Del Resp") - resp := createSubsDelResp(req) + xapp.Logger.Info("(%s) Send Subs Del Resp", e2termConn.desc) + + resp := &e2ap.E2APSubscriptionDeleteResponse{} + resp.RequestId.Id = req.RequestId.Id + resp.RequestId.Seq = req.RequestId.Seq + resp.FunctionId = req.FunctionId + e2SubsDelResp.Set(resp) xapp.Logger.Debug("%s", e2SubsDelResp.String()) packerr, packedMsg := e2SubsDelResp.Pack(nil) if packerr != nil { - testError(t, "(e2termConn) pack NOK %s", packerr.Error()) + testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error()) } params := &xapp.RMRParams{} @@ -358,60 +383,24 @@ func handle_e2term_subs_del_resp(t *testing.T, req *e2ap.E2APSubscriptionDeleteR snderr := e2termConn.RmrSend(params) if snderr != nil { - testError(t, "(e2termConn) RMR SEND FAILED: %s", snderr.Error()) + testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error()) } } -func handle_e2term_subs_del_reqandresp(t *testing.T) { - req, msg := handle_e2term_subs_del_req(t) - handle_e2term_subs_del_resp(t, req, msg) -} - //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- -func handle_xapp_subs_del_resp(t *testing.T) { - xapp.Logger.Info("handle_xapp_subs_del_resp start") - e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse() - - //--------------------------------- - // xapp activity: Recv Subs Del Resp - //--------------------------------- - select { - case msg := <-xappConn.rmrConChan: - if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_RESP"] { - testError(t, "(xappConn) Received non RIC_SUB_DEL_RESP message") - } else { - xapp.Logger.Info("(xappConn) Recv Subs Del Resp") - - packedData := &packer.PackedData{} - packedData.Buf = msg.Payload - unpackerr := e2SubsDelResp.UnPack(packedData) - if unpackerr != nil { - testError(t, "(xappConn) RIC_SUB_DEL_RESP unpack failed err: %s", unpackerr.Error()) - } - geterr, _ := e2SubsDelResp.Get() - if geterr != nil { - testError(t, "(xappConn) RIC_SUB_DEL_RESP get failed err: %s", geterr.Error()) - } - +func (mc *testingMainControl) wait_subs_clean(t *testing.T, e2SubsId int, secs int) bool { + i := 1 + for ; i <= secs*2; i++ { + if mc.c.registry.IsValidSequenceNumber(uint16(e2SubsId)) == false { + return true } - case <-time.After(15 * time.Second): - testError(t, "(xappConn) Not Received RIC_SUB_DEL_RESP within 15 secs") + time.Sleep(500 * time.Millisecond) } -} - -//----------------------------------------------------------------------------- -// -//----------------------------------------------------------------------------- -func handle_wait_subs_clean(t *testing.T, e2SubsId int) bool { - xapp.Logger.Info("handle_wait_subs_clean start") - if mainCtrl.wait_subs_clean(e2SubsId, 10) == false { - testError(t, "(general) no clean within 10 secs") - return false - } - return true + testError(t, "(general) no clean within %d secs", secs) + return false } //----------------------------------------------------------------------------- @@ -449,18 +438,20 @@ func handle_wait_subs_clean(t *testing.T, e2SubsId int) bool { // //----------------------------------------------------------------------------- func TestSubReqAndSubDelOk(t *testing.T) { - xapp.Logger.Info("TestSubReqAndSubDelOk start") + xapp.Logger.Info("TestSubReqAndSubDelOk") - handle_xapp_subs_req(t) - handle_e2term_subs_reqandresp(t) - e2SubsId := handle_xapp_subs_resp(t) + xappConn1.handle_xapp_subs_req(t, true) + crereq, cremsg := e2termConn.handle_e2term_subs_req(t) + e2termConn.handle_e2term_subs_resp(t, crereq, cremsg) + e2SubsId := xappConn1.handle_xapp_subs_resp(t) - handle_xapp_subs_del_req(t, e2SubsId) - handle_e2term_subs_del_reqandresp(t) - handle_xapp_subs_del_resp(t) + xappConn1.handle_xapp_subs_del_req(t, true, e2SubsId) + delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t) + e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg) + xappConn1.handle_xapp_subs_del_resp(t) //Wait that subs is cleaned - handle_wait_subs_clean(t, e2SubsId) + mainCtrl.wait_subs_clean(t, e2SubsId, 10) } //----------------------------------------------------------------------------- @@ -492,24 +483,25 @@ func TestSubReqAndSubDelOk(t *testing.T) { // //----------------------------------------------------------------------------- func TestSubReqRetransmission(t *testing.T) { - xapp.Logger.Info("TestSubReqRetransmission start") + xapp.Logger.Info("TestSubReqRetransmission") //Subs Create - handle_xapp_subs_req(t) - req, msg := handle_e2term_subs_req(t) - handle_xapp_subs_req(t) + xappConn1.handle_xapp_subs_req(t, true) + crereq, cremsg := e2termConn.handle_e2term_subs_req(t) + xappConn1.handle_xapp_subs_req(t, false) - handle_e2term_subs_resp(t, req, msg) + e2termConn.handle_e2term_subs_resp(t, crereq, cremsg) - e2SubsId := handle_xapp_subs_resp(t) + e2SubsId := xappConn1.handle_xapp_subs_resp(t) //Subs Delete - handle_xapp_subs_del_req(t, e2SubsId) - handle_e2term_subs_del_reqandresp(t) - handle_xapp_subs_del_resp(t) + xappConn1.handle_xapp_subs_del_req(t, true, e2SubsId) + delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t) + e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg) + xappConn1.handle_xapp_subs_del_resp(t) //Wait that subs is cleaned - handle_wait_subs_clean(t, e2SubsId) + mainCtrl.wait_subs_clean(t, e2SubsId, 10) } //----------------------------------------------------------------------------- @@ -540,23 +532,98 @@ func TestSubReqRetransmission(t *testing.T) { // //----------------------------------------------------------------------------- func TestSubDelReqRetransmission(t *testing.T) { - xapp.Logger.Info("TestSubDelReqRetransmission start") + xapp.Logger.Info("TestSubDelReqRetransmission") //Subs Create - handle_xapp_subs_req(t) - handle_e2term_subs_reqandresp(t) - e2SubsId := handle_xapp_subs_resp(t) + xappConn1.handle_xapp_subs_req(t, true) + crereq, cremsg := e2termConn.handle_e2term_subs_req(t) + e2termConn.handle_e2term_subs_resp(t, crereq, cremsg) + e2SubsId := xappConn1.handle_xapp_subs_resp(t) //Subs Delete - handle_xapp_subs_del_req(t, e2SubsId) - req, msg := handle_e2term_subs_del_req(t) + xappConn1.handle_xapp_subs_del_req(t, true, e2SubsId) + delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t) <-time.After(2 * time.Second) + xappConn1.handle_xapp_subs_del_req(t, false, e2SubsId) + + e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg) + xappConn1.handle_xapp_subs_del_resp(t) - handle_xapp_subs_del_req(t, e2SubsId) + //Wait that subs is cleaned + mainCtrl.wait_subs_clean(t, e2SubsId, 10) +} - handle_e2term_subs_del_resp(t, req, msg) +//----------------------------------------------------------------------------- +// TestSubReqAndSubDelOkTwoParallel +// +// stub stub +// +-------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | +// +-------+ +---------+ +---------+ +// | | | +// | | | +// | | | +// | SubReq1 | | +// |------------->| | +// | | | +// | | SubReq1 | +// | |------------->| +// | | | +// | SubReq2 | | +// |------------->| | +// | | | +// | | SubReq2 | +// | |------------->| +// | | | +// | | SubResp1 | +// | |<-------------| +// | | SubResp2 | +// | |<-------------| +// | | | +// | SubResp1 | | +// |<-------------| | +// | SubResp2 | | +// |<-------------| | +// | | | +// | [SUBS 1 DELETE] | +// | | | +// | [SUBS 2 DELETE] | +// | | | +// +//----------------------------------------------------------------------------- +func TestSubReqAndSubDelOkTwoParallel(t *testing.T) { + xapp.Logger.Info("TestSubReqAndSubDelOkTwoParallel") + + //Req1 + xappConn1.handle_xapp_subs_req(t, true) + crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t) + + //Req2 + xappConn2.handle_xapp_subs_req(t, true) + crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t) + + //Resp1 + e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1) + e2SubsId1 := xappConn1.handle_xapp_subs_resp(t) + + //Resp2 + e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2) + e2SubsId2 := xappConn2.handle_xapp_subs_resp(t) + + //Del1 + xappConn1.handle_xapp_subs_del_req(t, true, e2SubsId1) + delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t) + e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1) + xappConn1.handle_xapp_subs_del_resp(t) + //Wait that subs is cleaned + mainCtrl.wait_subs_clean(t, e2SubsId1, 10) + //Del2 + xappConn2.handle_xapp_subs_del_req(t, true, e2SubsId2) + delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t) + e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2) + xappConn2.handle_xapp_subs_del_resp(t) //Wait that subs is cleaned - handle_wait_subs_clean(t, e2SubsId) + mainCtrl.wait_subs_clean(t, e2SubsId2, 10) }