import (
"fmt"
+ "runtime/debug"
"strconv"
"testing"
"time"
}
type E2RestIds struct {
- RestSubsId string
- E2SubsId uint32
+ RestSubsId string
+ E2SubsId uint32
+ ErrorCause string
+ ErrorSource string
+ TimeoutType string
}
func (trans *RmrTransactionId) String() string {
trans.xid = xid
}
trans.meid = &xapp.RMRMeid{RanName: ranname}
- tc.Info("New test %s", trans.String())
+ tc.Debug("New test %s", trans.String())
return trans
}
p.Fail.RequestId.Id = p.Req.RequestId.Id
p.Fail.RequestId.InstanceId = p.Req.RequestId.InstanceId
p.Fail.FunctionId = p.Req.FunctionId
- p.Fail.ActionNotAdmittedList.Items = make([]e2ap.ActionNotAdmittedItem, len(p.Req.ActionSetups))
- for index := int(0); index < len(p.Fail.ActionNotAdmittedList.Items); index++ {
- p.Fail.ActionNotAdmittedList.Items[index].ActionId = p.Req.ActionSetups[index].ActionId
- p.SetCauseVal(index, 5, 1)
- }
+ p.Fail.Cause.Content = e2ap.E2AP_CauseContent_RICrequest
+ p.Fail.Cause.Value = e2ap.E2AP_CauseValue_RICrequest_control_message_invalid
}
func (p *E2StubSubsFailParams) SetCauseVal(ind int, content uint8, causeval uint8) {
- if ind < 0 {
- for index := int(0); index < len(p.Fail.ActionNotAdmittedList.Items); index++ {
- p.Fail.ActionNotAdmittedList.Items[index].Cause.Content = content
- p.Fail.ActionNotAdmittedList.Items[index].Cause.Value = causeval
- }
- return
- }
- p.Fail.ActionNotAdmittedList.Items[ind].Cause.Content = content
- p.Fail.ActionNotAdmittedList.Items[ind].Cause.Value = causeval
+ p.Fail.Cause.Content = content
+ p.Fail.Cause.Value = causeval
}
//-----------------------------------------------------------------------------
trans = tc.NewRmrTransactionId("", "RAN_NAME_1")
}
- tc.Info("SendSubsReq %s", trans.String())
+ tc.Debug("SendSubsReq %s", trans.String())
e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest()
//---------------------------------
params.Xid = trans.xid
params.Mbuf = nil
- tc.Info("SEND SUB REQ: %s", params.String())
+ tc.Debug("SEND SUB REQ: %s", params.String())
snderr := tc.SendWithRetry(params, false, 5)
if snderr != nil {
tc.TestError(t, "RMR SEND FAILED: %s %s", trans.String(), snderr.Error())
//
//-----------------------------------------------------------------------------
func (tc *E2Stub) RecvSubsReq(t *testing.T) (*e2ap.E2APSubscriptionRequest, *xapp.RMRParams) {
- tc.Info("RecvSubsReq")
+ tc.Debug("RecvSubsReq")
e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest()
//---------------------------------
if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_REQ"] {
tc.TestError(t, "Received wrong mtype expected %s got %s, error", "RIC_SUB_REQ", xapp.RicMessageTypeToName[msg.Mtype])
} else {
- tc.Info("Recv Subs Req")
+ tc.Debug("Recv Subs Req")
packedData := &e2ap.PackedData{}
packedData.Buf = msg.Payload
unpackerr, req := e2SubsReq.UnPack(packedData)
//
//-----------------------------------------------------------------------------
func (tc *E2Stub) SendSubsResp(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *xapp.RMRParams) {
- tc.Info("SendSubsResp")
+ tc.Debug("SendSubsResp")
e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse()
//---------------------------------
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.Value = 1
- resp.ActionNotAdmittedList.Items = append(resp.ActionNotAdmittedList.Items, item)
+ packerr, packedMsg := e2SubsResp.Pack(resp)
+ if packerr != nil {
+ tc.TestError(t, "pack NOK %s", packerr.Error())
+ }
+ tc.Debug("%s", e2SubsResp.String())
+
+ params := &xapp.RMRParams{}
+ params.Mtype = xapp.RIC_SUB_RESP
+ //params.SubId = msg.SubId
+ params.SubId = -1
+ params.Payload = packedMsg.Buf
+ params.PayloadLen = len(packedMsg.Buf)
+ params.Meid = msg.Meid
+ //params.Xid = msg.Xid
+ params.Mbuf = nil
+
+ tc.Debug("SEND SUB RESP: %s", params.String())
+ snderr := tc.SendWithRetry(params, false, 5)
+ if snderr != nil {
+ tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error())
+ }
+}
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+func (tc *E2Stub) SendPartialSubsResp(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *xapp.RMRParams, actionNotAdmittedList e2ap.ActionNotAdmittedList) {
+ tc.Debug("SendPartialSubsResp")
+
+ if len(actionNotAdmittedList.Items) == 0 {
+ tc.TestError(t, "SendPartialSubsResp() Empty actionNotAdmittedList.Items")
+ return
+ }
+
+ e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse()
+
+ //---------------------------------
+ // e2term activity: Send Subs Resp
+ //---------------------------------
+ resp := &e2ap.E2APSubscriptionResponse{}
+
+ resp.RequestId.Id = req.RequestId.Id
+ resp.RequestId.InstanceId = req.RequestId.InstanceId
+ resp.FunctionId = req.FunctionId
+
+ for index, actionNotAdmittedItem := range actionNotAdmittedList.Items {
+ for _, ActionToBeSetupItem := range req.ActionSetups {
+ if ActionToBeSetupItem.ActionId == actionNotAdmittedItem.ActionId {
+ actionNotAdmittedItem := e2ap.ActionNotAdmittedItem{}
+ actionNotAdmittedItem.ActionId = ActionToBeSetupItem.ActionId
+ actionNotAdmittedItem.Cause.Content = 1
+ actionNotAdmittedItem.Cause.Value = 8
+ resp.ActionNotAdmittedList.Items = append(resp.ActionNotAdmittedList.Items, actionNotAdmittedItem)
+ // Remove the element
+ req.ActionSetups = append(req.ActionSetups[:index], req.ActionSetups[index+1:]...)
+
+ }
+ }
+ }
+ for _, ActionToBeSetupItem := range req.ActionSetups {
+ actionAdmittedItem := e2ap.ActionAdmittedItem{}
+ actionAdmittedItem.ActionId = ActionToBeSetupItem.ActionId
+ resp.ActionAdmittedList.Items = append(resp.ActionAdmittedList.Items, actionAdmittedItem)
}
packerr, packedMsg := e2SubsResp.Pack(resp)
//params.Xid = msg.Xid
params.Mbuf = nil
- tc.Info("SEND SUB RESP: %s", params.String())
+ tc.Debug("SEND SUB RESP: %s", params.String())
snderr := tc.SendWithRetry(params, false, 5)
if snderr != nil {
tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error())
params.Mbuf = nil
if params.Mtype == xapp.RIC_SUB_RESP {
- tc.Info("SEND INVALID ASN.1 SUB RESP")
+ tc.Debug("SEND INVALID ASN.1 SUB RESP")
} else if params.Mtype == xapp.RIC_SUB_FAILURE {
- tc.Info("SEND INVALID ASN.1 SUB FAILURE")
+ tc.Debug("SEND INVALID ASN.1 SUB FAILURE")
} else if params.Mtype == xapp.RIC_SUB_DEL_RESP {
- tc.Info("SEND INVALID ASN.1 SUB DEL RESP")
+ tc.Debug("SEND INVALID ASN.1 SUB DEL RESP")
} else if params.Mtype == xapp.RIC_SUB_DEL_FAILURE {
- tc.Info("SEND INVALID ASN.1 SUB DEL FAILURE")
+ tc.Debug("SEND INVALID ASN.1 SUB DEL FAILURE")
}
snderr := tc.SendWithRetry(params, false, 5)
if snderr != nil {
//
//-----------------------------------------------------------------------------
func (tc *E2Stub) RecvSubsResp(t *testing.T, trans *RmrTransactionId) uint32 {
- tc.Info("RecvSubsResp")
+ tc.Debug("RecvSubsResp")
e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse()
var e2SubsId uint32
if unpackerr != nil {
tc.TestError(t, "RIC_SUB_RESP unpack failed err: %s", unpackerr.Error())
}
- tc.Info("Recv Subs Resp rmr: xid=%s subid=%d, asn: instanceid=%d", msg.Xid, msg.SubId, resp.RequestId.InstanceId)
+ tc.Debug("Recv Subs Resp rmr: xid=%s subid=%d, asn: instanceid=%d", msg.Xid, msg.SubId, resp.RequestId.InstanceId)
return e2SubsId
}
} else {
//-----------------------------------------------------------------------------
func (tc *E2Stub) SendSubsFail(t *testing.T, fparams *E2StubSubsFailParams, msg *xapp.RMRParams) {
- tc.Info("SendSubsFail")
+ tc.Debug("SendSubsFail")
e2SubsFail := e2asnpacker.NewPackerSubscriptionFailure()
//---------------------------------
params.Xid = msg.Xid
params.Mbuf = nil
- tc.Info("SEND SUB FAIL: %s", params.String())
+ tc.Debug("SEND SUB FAIL: %s", params.String())
snderr := tc.SendWithRetry(params, false, 5)
if snderr != nil {
tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error())
//
//-----------------------------------------------------------------------------
func (tc *E2Stub) RecvSubsFail(t *testing.T, trans *RmrTransactionId) uint32 {
- tc.Info("RecvSubsFail")
+ tc.Debug("RecvSubsFail")
e2SubsFail := e2asnpacker.NewPackerSubscriptionFailure()
var e2SubsId uint32
if unpackerr != nil {
tc.TestError(t, "RIC_SUB_FAILURE unpack failed err: %s", unpackerr.Error())
}
- tc.Info("Recv Subs Fail rmr: xid=%s subid=%d, asn: instanceid=%d", msg.Xid, msg.SubId, resp.RequestId.InstanceId)
+ tc.Debug("Recv Subs Fail rmr: xid=%s subid=%d, asn: instanceid=%d", msg.Xid, msg.SubId, resp.RequestId.InstanceId)
return e2SubsId
}
} else {
trans = tc.NewRmrTransactionId("", "RAN_NAME_1")
}
- tc.Info("SendSubsDelReq %s", trans.String())
+ tc.Debug("SendSubsDelReq %s", trans.String())
e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
//---------------------------------
// xapp activity: Send Subs Del Req
params.Xid = trans.xid
params.Mbuf = nil
- tc.Info("SEND SUB DEL REQ: %s", params.String())
+ tc.Debug("SEND SUB DEL REQ: %s", params.String())
snderr := tc.SendWithRetry(params, false, 5)
if snderr != nil {
tc.TestError(t, "RMR SEND FAILED: %s %s", trans.String(), snderr.Error())
//
//-----------------------------------------------------------------------------
func (tc *E2Stub) RecvSubsDelReq(t *testing.T) (*e2ap.E2APSubscriptionDeleteRequest, *xapp.RMRParams) {
- tc.Info("RecvSubsDelReq")
+ tc.Debug("RecvSubsDelReq")
e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
//---------------------------------
if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_REQ"] {
tc.TestError(t, "Received wrong mtype expected %s got %s, error", "RIC_SUB_DEL_REQ", xapp.RicMessageTypeToName[msg.Mtype])
} else {
- tc.Info("Recv Subs Del Req")
+ tc.Debug("Recv Subs Del Req")
packedData := &e2ap.PackedData{}
packedData.Buf = msg.Payload
//
//-----------------------------------------------------------------------------
func (tc *E2Stub) SendSubsDelResp(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *xapp.RMRParams) {
- tc.Info("SendSubsDelResp")
+ tc.Debug("SendSubsDelResp")
e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
//---------------------------------
params.Xid = msg.Xid
params.Mbuf = nil
- tc.Info("SEND SUB DEL RESP: %s", params.String())
+ tc.Debug("SEND SUB DEL RESP: %s", params.String())
snderr := tc.SendWithRetry(params, false, 5)
if snderr != nil {
tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error())
//
//-----------------------------------------------------------------------------
func (tc *E2Stub) RecvSubsDelResp(t *testing.T, trans *RmrTransactionId) {
- tc.Info("RecvSubsDelResp")
+ tc.Debug("RecvSubsDelResp")
e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
//---------------------------------
if unpackerr != nil {
tc.TestError(t, "RIC_SUB_DEL_RESP unpack failed err: %s", unpackerr.Error())
}
- tc.Info("Recv Subs Del Resp rmr: xid=%s subid=%d, asn: instanceid=%d", msg.Xid, msg.SubId, resp.RequestId.InstanceId)
+ tc.Debug("Recv Subs Del Resp rmr: xid=%s subid=%d, asn: instanceid=%d", msg.Xid, msg.SubId, resp.RequestId.InstanceId)
return
}
} else {
//
//-----------------------------------------------------------------------------
func (tc *E2Stub) SendSubsDelFail(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *xapp.RMRParams) {
- tc.Info("SendSubsDelFail")
+ tc.Debug("SendSubsDelFail")
e2SubsDelFail := e2asnpacker.NewPackerSubscriptionDeleteFailure()
//---------------------------------
params.Xid = msg.Xid
params.Mbuf = nil
- tc.Info("SEND SUB DEL FAIL: %s", params.String())
+ tc.Debug("SEND SUB DEL FAIL: %s", params.String())
snderr := tc.SendWithRetry(params, false, 5)
if snderr != nil {
tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error())
// Callback handler for subscription response notifications
//-----------------------------------------------------------------------------
func (tc *E2Stub) SubscriptionRespHandler(resp *clientmodel.SubscriptionResponse) {
+
if tc.subscriptionId == "SUBSCRIPTIONID NOT SET" {
- tc.Info("REST notification received for %v while no SubscriptionID was not set for InstanceID=%v, RequestorID=%v (%v)",
- *resp.SubscriptionID, *resp.SubscriptionInstances[0].InstanceID, *resp.SubscriptionInstances[0].RequestorID, tc)
- tc.CallBackNotification <- *resp.SubscriptionInstances[0].InstanceID
+ tc.Debug("REST notification received for %v while no SubscriptionID was not set for E2EventInstanceID=%v, XappEventInstanceID=%v",
+ *resp.SubscriptionID, *resp.SubscriptionInstances[0].E2EventInstanceID, *resp.SubscriptionInstances[0].XappEventInstanceID)
+ tc.CallBackNotification <- *resp.SubscriptionInstances[0].E2EventInstanceID
} else if tc.subscriptionId == *resp.SubscriptionID {
- tc.Info("REST notification received SubscriptionID=%s, InstanceID=%v, RequestorID=%v (%v)",
- *resp.SubscriptionID, *resp.SubscriptionInstances[0].InstanceID, *resp.SubscriptionInstances[0].RequestorID, tc)
- tc.CallBackNotification <- *resp.SubscriptionInstances[0].InstanceID
+ tc.Debug("REST notification received SubscriptionID=%s, E2EventInstanceID=%v, RequestorID=%v",
+ *resp.SubscriptionID, *resp.SubscriptionInstances[0].E2EventInstanceID, *resp.SubscriptionInstances[0].XappEventInstanceID)
+ tc.CallBackNotification <- *resp.SubscriptionInstances[0].E2EventInstanceID
} else {
- tc.Info("MISMATCHING REST notification received SubscriptionID=%s<>%s, InstanceID=%v, RequestorID=%v (%v)",
- tc.subscriptionId, *resp.SubscriptionID, *resp.SubscriptionInstances[0].InstanceID, *resp.SubscriptionInstances[0].RequestorID, tc)
+ tc.Debug("MISMATCHING REST notification received SubscriptionID=%s<>%s, E2EventInstanceID=%v, XappEventInstanceID=%v",
+ tc.subscriptionId, *resp.SubscriptionID, *resp.SubscriptionInstances[0].E2EventInstanceID, *resp.SubscriptionInstances[0].XappEventInstanceID)
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
+
func (tc *E2Stub) ExpectRESTNotification(t *testing.T, restSubsId string) {
+ tc.expectNotification(t, restSubsId, "")
+}
+
+func (tc *E2Stub) ExpectRESTNotificationOk(t *testing.T, restSubsId string) {
+ tc.expectNotification(t, restSubsId, "allOk")
+}
+
+func (tc *E2Stub) ExpectRESTNotificationNok(t *testing.T, restSubsId string, expectError string) {
+ tc.expectNotification(t, restSubsId, expectError)
+}
- tc.Info("### Started to wait REST notification for %v on port %v f(RMR port %v), %v responses expected", restSubsId, *tc.clientEndpoint.HTTPPort, *tc.clientEndpoint.RMRPort, tc.requestCount)
+func (tc *E2Stub) expectNotification(t *testing.T, restSubsId string, expectError string) {
+
+ tc.Debug("### Started to wait REST notification for restSubsId= %v, RMRPort=%v, requestCount=%v responses expected", restSubsId, *tc.clientEndpoint.RMRPort, tc.requestCount)
tc.restSubsIdList = []string{restSubsId}
xapp.Subscription.SetResponseCB(tc.ListedRestNotifHandler)
if tc.requestCount == 0 {
- tc.TestError(t, "### NO REST notifications SET received for endpoint=%s, request zount ZERO! (%v)", tc.clientEndpoint, tc)
+ tc.TestError(t, "### NO REST notifications SET received for restSubsId= %v, RMRPort=%v, request count ZERO!", restSubsId, *tc.clientEndpoint.RMRPort)
}
go func() {
select {
case e2Ids := <-tc.CallBackListedNotifications:
if tc.requestCount == 0 {
- tc.TestError(t, "### REST notification count unexpectedly ZERO for %s (%v)", restSubsId, tc)
+ tc.TestError(t, "### REST notification count unexpectedly ZERO for restSubsId= %v", restSubsId)
} else if e2Ids.RestSubsId != restSubsId {
- tc.TestError(t, "### Unexpected REST notifications received |%s:%s| (%v)", e2Ids.RestSubsId, restSubsId, tc)
+ tc.TestError(t, "### Unexpected REST notifications received, expected %s but got %s instead", e2Ids.RestSubsId, restSubsId)
+ } else if e2Ids.ErrorCause == "" && expectError == "allFail" {
+ tc.TestError(t, "### Unexpected ok cause received from REST notifications |%s:%s|", e2Ids.RestSubsId, restSubsId)
+ } else if e2Ids.ErrorCause != "" && expectError == "allOk" {
+ tc.TestError(t, "### Unexpected ErrorCause: (%s), ErrorSource: (%s), TimeoutType: (%s) received from REST notifications |%s:%s|", e2Ids.ErrorCause, e2Ids.ErrorSource, e2Ids.TimeoutType, e2Ids.RestSubsId, restSubsId)
} else {
tc.requestCount--
if tc.requestCount == 0 {
- tc.Info("### All expected REST notifications received for %s (%v)", e2Ids.RestSubsId, tc)
+ tc.Debug("### All expected REST notifications received for restSubsId= %v)", e2Ids.RestSubsId)
} else {
- tc.Info("### Expected REST notifications received for %s, (%v)", e2Ids.RestSubsId, tc)
+ tc.Debug("### Expected REST notifications received for restSubsId= %v", e2Ids.RestSubsId)
+ }
+ if e2Ids.ErrorCause != "" && expectError == "allFail" {
+ tc.Debug("### REST Notification: RestSubsId: %s, ErrorCause: %s, ErrorSource: (%s), TimeoutType: (%s)", e2Ids.RestSubsId, e2Ids.ErrorCause, e2Ids.ErrorSource, e2Ids.TimeoutType)
}
- tc.Info("### REST Notification received Notif for %s : %v", e2Ids.RestSubsId, e2Ids.E2SubsId)
+ tc.Debug("### REST Notification received Notif for %s : %v", e2Ids.RestSubsId, e2Ids.E2SubsId)
tc.ListedRESTNotifications <- e2Ids
+ if len(tc.ListedRESTNotifications) > 1 {
+ panic("expectNotification - ListedRESTNotifications stacking up")
+ }
}
case <-time.After(15 * time.Second):
err := fmt.Errorf("### Timeout 15s expired while expecting REST notification for subsId: %v", restSubsId)
}
func (tc *E2Stub) WaitRESTNotification(t *testing.T, restSubsId string) uint32 {
+
+ stack := string(debug.Stack())
+
select {
case e2SubsId := <-tc.ListedRESTNotifications:
if e2SubsId.RestSubsId == restSubsId {
- tc.Info("### Expected REST notifications received %s, e2SubsId %v for endpoint=%s, (%v)", e2SubsId.RestSubsId, e2SubsId.E2SubsId, tc.clientEndpoint, tc)
+ tc.Debug("### Expected REST notifications received %s, e2SubsId %v", e2SubsId.RestSubsId, e2SubsId.E2SubsId)
return e2SubsId.E2SubsId
} else {
- tc.TestError(t, "### Unexpected REST notifications received %s, expected %s for endpoint=%s, (%v)", e2SubsId.RestSubsId, restSubsId, tc.clientEndpoint, tc)
+ tc.TestError(t, "### Unexpected REST notification %s received, expected %v", e2SubsId.RestSubsId, restSubsId)
+ xapp.Logger.Debug("CALL STACK:\n %s", stack)
return 0
}
case <-time.After(15 * time.Second):
err := fmt.Errorf("### Timeout 15s expired while waiting REST notification for subsId: %v", restSubsId)
tc.TestError(t, "%s", err.Error())
+ xapp.Logger.Debug("CALL STACK:\n %s", stack)
panic("WaitRESTNotification - timeout error")
}
- return 0
}
-func (tc *E2Stub) WaitRESTNotificationForAnySubscriptionId(t *testing.T) {
+// Note, this function should be followed by a handling of <-xappConn1.RESTNotification.
+func (tc *E2Stub) ExpectAnyNotification(t *testing.T) {
go func() {
- tc.Info("### REST notifications received for endpoint=%s, (%v)", tc.clientEndpoint, tc)
+ tc.Debug("### Started waiting ANY REST notifications received for RMRPort=%v", *tc.clientEndpoint.RMRPort)
select {
case e2SubsId := <-tc.CallBackNotification:
- tc.Info("### REST notifications received e2SubsId %v for endpoint=%s, (%v)", e2SubsId, tc.clientEndpoint, tc)
+ tc.Debug("### ANY REST notifications received for e2SubsId %v RMRPort=%v", e2SubsId, *tc.clientEndpoint.RMRPort)
tc.RESTNotification <- (uint32)(e2SubsId)
case <-time.After(15 * time.Second):
- err := fmt.Errorf("### Timeout 15s expired while waiting REST notification")
+ err := fmt.Errorf("### Timeout 15s expired while waiting ANY REST notification")
tc.TestError(t, "%s", err.Error())
tc.RESTNotification <- 0
}
}()
}
+func (tc *E2Stub) WaitAnyRESTNotification(t *testing.T) uint32 {
+
+ select {
+ case e2SubsId := <-tc.RESTNotification:
+ tc.Debug("### Expected ANY REST notification received for e2SubsId %v", e2SubsId)
+ return e2SubsId
+
+ case <-time.After(15 * time.Second):
+ err := fmt.Errorf("### Timeout 15s expired while waiting ANY REST notification")
+ tc.TestError(t, "%s", err.Error())
+ panic("WaitRESTNotification - timeout error")
+ }
+}
+
func (tc *E2Stub) ListedRestNotifHandler(resp *clientmodel.SubscriptionResponse) {
if len(tc.restSubsIdList) == 0 {
- tc.Error("Unexpected listed REST notifications received for endpoint=%s, expected restSubsId list size was ZERO!", tc.clientEndpoint)
+ tc.Error("Unexpected listed REST notifications received for SubscriptionID=%s, expected restSubsId list size was ZERO!", *resp.SubscriptionID)
} else {
for i, subsId := range tc.restSubsIdList {
if *resp.SubscriptionID == subsId {
- //tc.Info("Listed REST notifications received SubscriptionID=%s, InstanceID=%v, RequestorID=%v",
- // *resp.SubscriptionID, *resp.SubscriptionInstances[0].InstanceID, *resp.SubscriptionInstances[0].RequestorID)
+ //tc.Debug("Listed REST notifications received SubscriptionID=%s, InstanceID=%v, XappEventInstanceID=%v",
+ // *resp.SubscriptionID, *resp.SubscriptionInstances[0].InstanceID, *resp.SubscriptionInstances[0].XappEventInstanceID)
tc.restSubsIdList = append(tc.restSubsIdList[:i], tc.restSubsIdList[i+1:]...)
- //tc.Info("Removed %s from Listed REST notifications, %v entries left", *resp.SubscriptionID, len(tc.restSubsIdList))
+ //tc.Debug("Removed %s from Listed REST notifications, %v entries left", *resp.SubscriptionID, len(tc.restSubsIdList))
- tc.CallBackListedNotifications <- E2RestIds{*resp.SubscriptionID, uint32(*resp.SubscriptionInstances[0].InstanceID)}
+ // if resp.SubscriptionInstances[0].ErrorCause != nil {
+ tc.CallBackListedNotifications <- *tc.GetE2RestIds(resp)
+ // } else {
+ // tc.CallBackListedNotifications <- E2RestIds{*resp.SubscriptionID, uint32(*resp.SubscriptionInstances[0].E2EventInstanceID), "", "", ""}
+ // }
if len(tc.restSubsIdList) == 0 {
- //tc.Info("All listed REST notifications received for endpoint=%s", tc.clientEndpoint)
+ tc.Debug("All listed REST notifications received for SubscriptionID=%s", *resp.SubscriptionID)
}
return
}
}
- tc.Error("UNKONWN REST notification received SubscriptionID=%s<>%s, InstanceID=%v, RequestorID=%v (%v)",
- tc.subscriptionId, *resp.SubscriptionID, *resp.SubscriptionInstances[0].InstanceID, *resp.SubscriptionInstances[0].RequestorID, tc)
+ tc.Error("UNKONWN REST notification received SubscriptionID=%s<>%s, InstanceID=%v, XappEventInstanceID=%v",
+ tc.subscriptionId, *resp.SubscriptionID, *resp.SubscriptionInstances[0].E2EventInstanceID, *resp.SubscriptionInstances[0].XappEventInstanceID)
}
}
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+func (tc *E2Stub) GetE2RestIds(resp *clientmodel.SubscriptionResponse) *E2RestIds {
+
+ e2RestIds := &E2RestIds{}
+ if resp != nil {
+ if resp.SubscriptionID != nil {
+ e2RestIds.RestSubsId = *resp.SubscriptionID
+ }
+ if resp.SubscriptionInstances != nil {
+ if resp.SubscriptionInstances[0].E2EventInstanceID != nil {
+ e2RestIds.E2SubsId = uint32(*resp.SubscriptionInstances[0].E2EventInstanceID)
+ }
+ e2RestIds.ErrorCause = resp.SubscriptionInstances[0].ErrorCause
+ e2RestIds.ErrorSource = resp.SubscriptionInstances[0].ErrorSource
+ e2RestIds.TimeoutType = resp.SubscriptionInstances[0].TimeoutType
+ }
+ }
+ return e2RestIds
+}
+
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
func (tc *E2Stub) WaitListedRestNotifications(t *testing.T, restSubsIds []string) {
- tc.Info("Started to wait REST notifications %v on port %v f(RMR port %v)", restSubsIds, *tc.clientEndpoint.HTTPPort, *tc.clientEndpoint.RMRPort)
+ tc.Debug("Started to wait REST notifications for restSubsIds=%v, RMRPort=%v", restSubsIds, *tc.clientEndpoint.RMRPort)
tc.restSubsIdList = restSubsIds
xapp.Subscription.SetResponseCB(tc.ListedRestNotifHandler)
go func() {
select {
case e2Ids := <-tc.CallBackListedNotifications:
- tc.Info("Listed Notification waiter received Notif for %s : %v", e2Ids.RestSubsId, e2Ids.E2SubsId)
+ tc.Debug("Listed Notification waiter received Notif for %s : %v", e2Ids.RestSubsId, e2Ids.E2SubsId)
tc.ListedRESTNotifications <- e2Ids
case <-time.After(15 * time.Second):
err := fmt.Errorf("Timeout 15s expired while waiting Listed REST notification")
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
-func (tc *E2Stub) SendRESTSubsReq(t *testing.T, params *RESTSubsReqParams) string { // This need to be edited according to new specification
- tc.Info("======== Posting REST Report subscriptions to Submgr ======")
+func (tc *E2Stub) SendRESTSubsReq(t *testing.T, params *RESTSubsReqParams) string {
+ tc.Debug("======== Posting REST subscriptions to Submgr ======")
if params == nil {
- tc.Info("SendRESTReportSubsReq: params == nil")
+ tc.Debug("SendRESTReportSubsReq: params == nil")
return ""
}
- tc.subscriptionId = "SUBSCIPTIONID NOT SET"
+ tc.subscriptionId = "SUBSCRIPTIONID NOT SET"
resp, err := xapp.Subscription.Subscribe(¶ms.SubsReqParams)
if err != nil {
// Swagger generated code makes checks for the values that are inserted the subscription function
// If error cause is unknown and POST is not done, the problem is in the inserted values
- tc.Error("======== REST report subscriptions failed %s ========", err.Error())
+ tc.Error("======== REST subscription request failed %s ========", err.Error())
return ""
}
tc.subscriptionId = *resp.SubscriptionID
- tc.Info("======== REST report subscriptions posted successfully. SubscriptionID = %s, RequestCount = %v ========", *resp.SubscriptionID, tc.requestCount)
+ tc.Debug("======== REST subscriptions posted successfully. SubscriptionID = %s, RequestCount = %v ========", *resp.SubscriptionID, tc.requestCount)
return *resp.SubscriptionID
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
-func (tc *E2Stub) GetRESTSubsReqReportParams(subReqCount int, parameterSet int, actionDefinitionPresent bool, actionParamCount int) *RESTSubsReqParams {
+func (tc *E2Stub) GetRESTSubsReqReportParams(subReqCount int) *RESTSubsReqParams {
reportParams := RESTSubsReqParams{}
- if parameterSet == 1 {
- reportParams.GetRESTSubsReqReportParams1(subReqCount, actionDefinitionPresent, actionParamCount, &tc.clientEndpoint, &tc.meid)
- } else if parameterSet == 2 {
-
- } else {
- tc.Error("Invalid parameterSet=%v", parameterSet)
- }
- tc.requestCount = subReqCount
- return &reportParams
-}
-
-//-----------------------------------------------------------------------------
-//
-//-----------------------------------------------------------------------------
-func (tc *E2Stub) GetRESTSubsReqReportParams1(subReqCount int, actionDefinitionPresent bool, actionParamCount int) *RESTSubsReqParams {
-
- reportParams := RESTSubsReqParams{}
- reportParams.GetRESTSubsReqReportParams1(subReqCount, actionDefinitionPresent, actionParamCount, &tc.clientEndpoint, &tc.meid)
+ reportParams.GetRESTSubsReqReportParams(subReqCount, &tc.clientEndpoint, &tc.meid)
tc.requestCount = subReqCount
return &reportParams
}
SubsReqParams clientmodel.SubscriptionParams
}
-func (p *RESTSubsReqParams) GetRESTSubsReqReportParams1(subReqCount int, actionDefinitionPresent bool, actionParamCount int, clientEndpoint *clientmodel.SubscriptionParamsClientEndpoint, meid *string) {
+func (p *RESTSubsReqParams) GetRESTSubsReqReportParams(subReqCount int, clientEndpoint *clientmodel.SubscriptionParamsClientEndpoint, meid *string) {
// E2SM-gNB-X2
p.SubsReqParams.ClientEndpoint = clientEndpoint
var rANFunctionID int64 = 33
p.SubsReqParams.RANFunctionID = &rANFunctionID
- // reqId := int64(1)
- //seqId := int64(1)
actionId := int64(1)
actionType := "report"
subsequestActioType := "continue"
for requestCount := 0; requestCount < subReqCount; requestCount++ {
reqId := int64(requestCount) + 1
- seqId := int64(requestCount) + 1
subscriptionDetail := &clientmodel.SubscriptionDetail{
- RequestorID: &reqId,
- InstanceID: &seqId,
- EventTriggers: &clientmodel.EventTriggerDefinition{
- OctetString: "1234" + strconv.Itoa(requestCount),
+ XappEventInstanceID: &reqId,
+ EventTriggers: clientmodel.EventTriggerDefinition{
+ int64(1234 + requestCount),
},
ActionToBeSetupList: clientmodel.ActionsToBeSetup{
&clientmodel.ActionToBeSetup{
ActionID: &actionId,
ActionType: &actionType,
- ActionDefinition: &clientmodel.ActionDefinition{
- OctetString: "5678" + strconv.Itoa(requestCount),
+ ActionDefinition: clientmodel.ActionDefinition{
+ int64(5678 + requestCount),
},
SubsequentAction: &clientmodel.SubsequentAction{
SubsequentActionType: &subsequestActioType,
if p.SubsReqParams.ClientEndpoint.Host != "" {
if p.SubsReqParams.ClientEndpoint.Host != host {
- // Renaming toto, print something tc.Info("Posting REST subscription request to Submgr")
+ // Renaming toto, print something tc.Debug("Posting REST subscription request to Submgr")
err := fmt.Errorf("hostname change attempt: %s -> %s", p.SubsReqParams.ClientEndpoint.Host, host)
panic(err)
}
}
}
+func (p *RESTSubsReqParams) SetE2SubscriptionDirectives(E2RetryCount int64, E2TimeoutTimerValue int64, RMRRoutingNeeded bool) {
+
+ E2SubscriptionDirectives := &clientmodel.SubscriptionParamsE2SubscriptionDirectives{}
+ p.SubsReqParams.E2SubscriptionDirectives = E2SubscriptionDirectives
+ p.SubsReqParams.E2SubscriptionDirectives.E2RetryCount = &E2RetryCount
+ p.SubsReqParams.E2SubscriptionDirectives.E2TimeoutTimerValue = E2TimeoutTimerValue
+ p.SubsReqParams.E2SubscriptionDirectives.RMRRoutingNeeded = RMRRoutingNeeded
+}
+
+func (p *RESTSubsReqParams) RemoveE2SubscriptionDirectives() {
+
+ p.SubsReqParams.E2SubscriptionDirectives = nil
+}
+
func (p *RESTSubsReqParams) SetSubActionTypes(actionType string) {
for _, subDetail := range p.SubsReqParams.SubscriptionDetails {
}
}
-func (p *RESTSubsReqParams) SetSubActionDefinition(actionDefinition string) {
+func (p *RESTSubsReqParams) SetSubActionDefinition(actionDefinition []int64) {
for _, subDetail := range p.SubsReqParams.SubscriptionDetails {
for _, action := range subDetail.ActionToBeSetupList {
if action != nil {
- action.ActionDefinition.OctetString = actionDefinition
+ action.ActionDefinition = actionDefinition
}
}
}
}
-func (p *RESTSubsReqParams) SetSubEventTriggerDefinition(eventTriggerDefinition string) {
+func (p *RESTSubsReqParams) SetSubEventTriggerDefinition(eventTriggerDefinition []int64) {
for _, subDetail := range p.SubsReqParams.SubscriptionDetails {
if subDetail != nil {
- subDetail.EventTriggers.OctetString = eventTriggerDefinition
+ subDetail.EventTriggers = eventTriggerDefinition
}
}
}
-func (p *RESTSubsReqParams) AppendActionToActionToBeSetupList(actionId int64, actionType string, actionDefinition string, subsequentActionType string, timeToWait string) {
+func (p *RESTSubsReqParams) AppendActionToActionToBeSetupList(actionId int64, actionType string, actionDefinition []int64, subsequentActionType string, timeToWait string) {
actionToBeSetup := &clientmodel.ActionToBeSetup{
- ActionID: &actionId,
- ActionType: &actionType,
- ActionDefinition: &clientmodel.ActionDefinition{
- OctetString: actionDefinition,
- },
+ ActionID: &actionId,
+ ActionType: &actionType,
+ ActionDefinition: clientmodel.ActionDefinition(actionDefinition),
SubsequentAction: &clientmodel.SubsequentAction{
SubsequentActionType: &subsequentActionType,
TimeToWait: &timeToWait,
}
}
+func (p *RESTSubsReqParams) SetSubscriptionID(SubscriptionID *string) {
+
+ if *SubscriptionID == "" {
+ return
+ }
+ p.SubsReqParams.SubscriptionID = *SubscriptionID
+}
+
+func (p *RESTSubsReqParams) SetXappEventInstanceID(xappEventInstanceId int64) {
+
+ for _, subDetail := range p.SubsReqParams.SubscriptionDetails {
+ if subDetail != nil {
+ subDetail.XappEventInstanceID = &xappEventInstanceId
+ }
+ }
+}
+
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
func (tc *E2Stub) SendRESTSubsDelReq(t *testing.T, subscriptionID *string) {
+ tc.Debug("======== Posting REST DELETE subscription(s) to Submgr ======")
+
if *subscriptionID == "" {
tc.Error("REST error in deleting subscriptions. Empty SubscriptionID = %s", *subscriptionID)
}
- tc.Info("REST deleting E2 subscriptions. SubscriptionID = %s", *subscriptionID)
+ tc.Debug("REST deleting E2 subscriptions. SubscriptionID = %s", *subscriptionID)
err := xapp.Subscription.Unsubscribe(*subscriptionID)
if err != nil {
tc.Error("REST Delete subscription failed %s", err.Error())
}
- tc.Info("REST delete subscription pushed to submgr successfully. SubscriptionID = %s", *subscriptionID)
+ tc.Debug("REST delete subscription pushed to submgr successfully. SubscriptionID = %s", *subscriptionID)
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
-func (tc *E2Stub) GetRESTSubsReqPolicyParams(subReqCount int, actionDefinitionPresent bool, policyParamCount int) *RESTSubsReqParams {
+func (tc *E2Stub) GetRESTSubsReqPolicyParams(subReqCount int) *RESTSubsReqParams {
policyParams := RESTSubsReqParams{}
- policyParams.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount, &tc.clientEndpoint, &tc.meid)
+ policyParams.GetRESTSubsReqPolicyParams(subReqCount, &tc.clientEndpoint, &tc.meid)
tc.requestCount = subReqCount
return &policyParams
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
-func (p *RESTSubsReqParams) GetRESTSubsReqPolicyParams(subReqCount int, actionDefinitionPresent bool, policyParamCount int, clientEndpoint *clientmodel.SubscriptionParamsClientEndpoint, meid *string) {
+func (tc *E2Stub) DecrementRequestCount() {
+ if tc.requestCount > 0 {
+ tc.requestCount -= 1
+ } else {
+ tc.Error("FAILED to decrement request count, count already ZERO")
+ }
+}
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+func (p *RESTSubsReqParams) GetRESTSubsReqPolicyParams(subReqCount int, clientEndpoint *clientmodel.SubscriptionParamsClientEndpoint, meid *string) {
p.SubsReqParams.ClientEndpoint = clientEndpoint
p.SubsReqParams.Meid = meid
var rANFunctionID int64 = 33
p.SubsReqParams.RANFunctionID = &rANFunctionID
-
- // reqId := int64(1)
- //seqId := int64(1)
actionId := int64(1)
actionType := "policy"
subsequestActioType := "continue"
for requestCount := 0; requestCount < subReqCount; requestCount++ {
reqId := int64(requestCount) + 1
- seqId := int64(0)
subscriptionDetail := &clientmodel.SubscriptionDetail{
- RequestorID: &reqId,
- InstanceID: &seqId,
- EventTriggers: &clientmodel.EventTriggerDefinition{
- OctetString: "1234" + strconv.Itoa(requestCount),
+ XappEventInstanceID: &reqId,
+ EventTriggers: clientmodel.EventTriggerDefinition{
+ int64(1234 + requestCount),
},
ActionToBeSetupList: clientmodel.ActionsToBeSetup{
&clientmodel.ActionToBeSetup{
ActionID: &actionId,
ActionType: &actionType,
- ActionDefinition: &clientmodel.ActionDefinition{
- OctetString: "5678" + strconv.Itoa(requestCount),
+ ActionDefinition: clientmodel.ActionDefinition{
+ int64(5678 + requestCount),
},
SubsequentAction: &clientmodel.SubsequentAction{
SubsequentActionType: &subsequestActioType,
}
p.SubsReqParams.SubscriptionDetails = append(p.SubsReqParams.SubscriptionDetails, subscriptionDetail)
}
+}
+
+func (p *RESTSubsReqParams) SetSubscriptionDirectives(e2Timeout int64, e2RetryCount int64, routingNeeded bool) {
+
+ e2SubscriptionDirectives := &clientmodel.SubscriptionParamsE2SubscriptionDirectives{}
+ e2SubscriptionDirectives.E2TimeoutTimerValue = e2Timeout
+ e2SubscriptionDirectives.E2RetryCount = &e2RetryCount
+ e2SubscriptionDirectives.RMRRoutingNeeded = routingNeeded
+ p.SubsReqParams.E2SubscriptionDirectives = e2SubscriptionDirectives
}
Code Review / ric-plt / submgr.git / blobdiff