X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=pkg%2Fcontrol%2Fut_messaging_test.go;h=92ff1785ca80b98f3ca3e9433197ffc4e1b12d4e;hb=c9ef0ba044f66201c34f42e3bb459e0ae4e6855b;hp=415c438767cbce4f04be2eb6d3916cc87dd364e1;hpb=5ae07f45858be99f4309cb75461fb0283ebdc892;p=ric-plt%2Fsubmgr.git diff --git a/pkg/control/ut_messaging_test.go b/pkg/control/ut_messaging_test.go index 415c438..92ff178 100644 --- a/pkg/control/ut_messaging_test.go +++ b/pkg/control/ut_messaging_test.go @@ -24,11 +24,28 @@ import ( "time" "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap" + "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper" "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststube2ap" "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp" "github.com/stretchr/testify/assert" ) +func TestRESTSubReqAndDeleteOkWithE2apUtWrapper(t *testing.T) { + + // The effect of this call shall endure thgough the UT suite! + // If this causes any issues, the previout interface can be restored + // like this: + // SetPackerIf(e2ap_wrapper.NewAsn1E2APPacker()) + + SetPackerIf(e2ap_wrapper.NewUtAsn1E2APPacker()) + + restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil) + + deleteSubscription(t, xappConn1, e2termConn1, &restSubId) + + waitSubsCleanup(t, e2SubsId, 10) +} + //----------------------------------------------------------------------------- // TestSubReqAndRouteNok // @@ -2242,19 +2259,16 @@ func TestRESTSubReqAndRouteNok(t *testing.T) { }) const subReqCount int = 1 - const parameterSet = 1 - const actionDefinitionPresent bool = true - const actionParamCount int = 1 - waiter := rtmgrHttp.AllocNextEvent(false) + // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side + waiter := rtmgrHttp.AllocNextSleep(50, false) newSubsId := mainCtrl.get_registry_next_subid(t) // Req - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) - + xappConn1.ExpectRESTNotification(t, restSubId) waiter.WaitResult(t) - xappConn1.ExpectRESTNotification(t, restSubId) e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId) @@ -2293,7 +2307,7 @@ func TestRESTSubReqAndRouteUpdateNok(t *testing.T) { // xapp2 ROUTE creation shall fail with 400 from rtmgr -> submgr waiter := rtmgrHttp.AllocNextEvent(false) newSubsId := mainCtrl.get_registry_next_subid(t) - params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params = xappConn2.GetRESTSubsReqReportParams(subReqCount) params.SetMeid("RAN_NAME_1") restSubId2 := xappConn2.SendRESTSubsReq(t, params) xapp.Logger.Info("Send REST subscriber request for second subscriber : %v", restSubId2) @@ -2424,7 +2438,7 @@ func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) { // | | | // //----------------------------------------------------------------------------- -/* + func TestRESTSubReqRetransmission(t *testing.T) { CaseBegin("TestRESTSubReqRetransmission") @@ -2444,14 +2458,11 @@ func TestRESTSubReqRetransmission(t *testing.T) { // Subs Create const subReqCount int = 1 - const parameterSet = 1 - const actionDefinitionPresent bool = true - const actionParamCount int = 1 // In order to force both XAPP's to create their own subscriptions, force rtmgr to block a while so that 2nd create // gets into execution before the rtmgrg responds for the first one. waiter := rtmgrHttp.AllocNextSleep(10, true) - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId1 := xappConn1.SendRESTSubsReq(t, params) restSubId2 := xappConn2.SendRESTSubsReq(t, params) @@ -2476,19 +2487,18 @@ func TestRESTSubReqRetransmission(t *testing.T) { delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t) e2termConn1.SendSubsDelResp(t, delreq1, delmsg1) - // Wait that subs is cleaned - mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10) - // Del2 xappConn2.SendRESTSubsDelReq(t, &restSubId2) delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t) e2termConn1.SendSubsDelResp(t, delreq2, delmsg2) + mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10) + waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10) mainCtrl.VerifyCounterValues(t) } -*/ + func TestRESTSubDelReqRetransmission(t *testing.T) { CaseBegin("TestRESTSubDelReqRetransmission") @@ -2569,12 +2579,9 @@ func TestRESTSubReqDelReq(t *testing.T) { }) const subReqCount int = 1 - const parameterSet = 1 - const actionDefinitionPresent bool = true - const actionParamCount int = 1 // Req - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) // Del. This will fail as processing of the subscription @@ -2617,12 +2624,12 @@ func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) { }) //Req1 - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId1 := xappConn1.SendRESTSubsReq(t, params) xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1) //Req2 - params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params = xappConn2.GetRESTSubsReqReportParams(subReqCount) restSubId2 := xappConn2.SendRESTSubsReq(t, params) xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2) @@ -2669,11 +2676,11 @@ func TestRESTSameSubsDiffRan(t *testing.T) { Counter{cSubDelRespToXapp, 2}, }) - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1) - params = xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params = xappConn1.GetRESTSubsReqReportParams(subReqCount) params.SetMeid("RAN_NAME_2") restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params) xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2) @@ -2707,7 +2714,7 @@ func TestRESTSubReqRetryInSubmgr(t *testing.T) { Counter{cSubDelRespToXapp, 1}, }) - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId) @@ -2785,7 +2792,7 @@ func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) { Counter{cSubDelRespFromE2, 1}, }) - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId) @@ -2820,7 +2827,7 @@ func TestREST2eTermNotRespondingToSubReq(t *testing.T) { Counter{cSubDelReqTimerExpiry, 2}, }) - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId) @@ -2897,7 +2904,7 @@ func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) { Counter{cSubDelReqTimerExpiry, 2}, }) - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId) @@ -2966,11 +2973,8 @@ func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) { }) const subReqCount int = 1 - const parameterSet = 1 - const actionDefinitionPresent bool = true - const actionParamCount int = 1 - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) @@ -3244,7 +3248,7 @@ func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) { queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"}) // Req2 - params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params = xappConn2.GetRESTSubsReqReportParams(subReqCount) params.SetMeid("RAN_NAME_1") xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler) @@ -3331,11 +3335,11 @@ func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) { Counter{cSubDelRespToXapp, 2}, }) - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId1 := xappConn1.SendRESTSubsReq(t, params) crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) - params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount) restSubId2 := xappConn2.SendRESTSubsReq(t, params2) xappConn1.ExpectRESTNotification(t, restSubId1) @@ -3428,18 +3432,15 @@ func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) { }) const subReqCount int = 1 - const parameterSet = 1 - const actionDefinitionPresent bool = true - const actionParamCount int = 1 // Req1 - params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId1 := xappConn1.SendRESTSubsReq(t, params1) crereq1, _ := e2termConn1.RecvSubsReq(t) // Req2 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId) - params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount) params2.SetMeid("RAN_NAME_1") restSubId2 := xappConn2.SendRESTSubsReq(t, params2) mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10) @@ -3448,15 +3449,14 @@ func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) { e2termConn1.RecvSubsReq(t) delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t) - xappConn1.ExpectRESTNotification(t, restSubId1) // or restSubId2? - // xappConn2.WaitRESTNotification(t) - e2termConn1.SendSubsDelResp(t, delreq1, delmsg1) - e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1) - xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId1) + xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2}) + e2termConn1.SendSubsDelResp(t, delreq1, delmsg1) - // e2SubsId2 := <-xappConn2.RESTNotification - // xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId2) + e2SubsIdA := <-xappConn1.ListedRESTNotifications + xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA) + e2SubsIdB := <-xappConn1.ListedRESTNotifications + xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB) // Del1 xappConn1.SendRESTSubsDelReq(t, &restSubId1) @@ -3464,8 +3464,10 @@ func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) { // Del2 xappConn2.SendRESTSubsDelReq(t, &restSubId2) + mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10) + //Wait that subs is cleaned - waitSubsCleanup(t, e2SubsId1, 10) + waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10) mainCtrl.VerifyCounterValues(t) } @@ -3534,18 +3536,15 @@ func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) { }) const subReqCount int = 1 - const parameterSet = 1 - const actionDefinitionPresent bool = true - const actionParamCount int = 1 // Req1 - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId1 := xappConn1.SendRESTSubsReq(t, params) crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) // Req2 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId) - params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount) params2.SetMeid("RAN_NAME_1") restSubId2 := xappConn2.SendRESTSubsReq(t, params2) mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10) @@ -3594,11 +3593,8 @@ func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) { }) const subReqCount int = 1 - const parameterSet = 1 - const actionDefinitionPresent bool = true - const actionParamCount int = 1 - params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount) + params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId) @@ -3681,18 +3677,15 @@ func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) { }) const subReqCount int = 1 - const parameterSet = 1 - const actionDefinitionPresent bool = true - const policyParamCount int = 1 // Req - params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount) + params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) // Policy change instanceId := int64(e2SubsId) // GetRESTSubsReqPolicyParams sets some coutners on tc side. - params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount) + params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount) params.SubsReqParams.SubscriptionDetails[0].InstanceID = &instanceId params.SetTimeToWait("w200ms") restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params) @@ -3765,17 +3758,14 @@ func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) { }) const subReqCount int = 1 - const parameterSet = 1 - const actionDefinitionPresent bool = true - const actionParamCount int = 1 // Req1 - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId1 := xappConn1.SendRESTSubsReq(t, params) crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) // Req2 - params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params = xappConn2.GetRESTSubsReqReportParams(subReqCount) params.SetMeid("RAN_NAME_11") // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1 // would not work as notification would not be received @@ -3893,11 +3883,8 @@ func TestRESTSubReqInsertAndSubDelOk(t *testing.T) { }) const subReqCount int = 1 - const parameterSet int = 1 - const actionDefinitionPresent bool = true - const actionParamCount int = 1 - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) params.SetSubActionTypes("insert") // Req @@ -3954,14 +3941,11 @@ func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) { }) const subReqCount int = 1 - const parameterSet = 1 - const actionDefinitionPresent bool = true - const actionParamCount int = 1 // Remove possible existing subscription mainCtrl.removeExistingSubscriptions(t) - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) //Req mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription @@ -4149,7 +4133,7 @@ func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) { xapp.Logger.Info("Send REST subscriber request for subscriber 1 : %v", restSubId1) // Create subscription 2 with same action - params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params = xappConn2.GetRESTSubsReqReportParams(subReqCount) params.SetMeid("RAN_NAME_1") xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler) xappConn2.WaitRESTNotificationForAnySubscriptionId(t) @@ -4167,8 +4151,10 @@ func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) { // mainCtrl.SimulateRestart(t) // xapp.Logger.Debug("mainCtrl.SimulateRestart done") - // Delete subscription 1 + // Delete subscription 1, and wait until it has removed the first endpoint + subepcnt := mainCtrl.get_subs_entrypoint_cnt(t, e2SubsId1) xappConn1.SendRESTSubsDelReq(t, &restSubId1) + mainCtrl.wait_subs_entrypoint_cnt_change(t, e2SubsId1, subepcnt, 10) // When SDL support for the REST Interface is added // the submgr restart statement below should be removed @@ -4176,7 +4162,6 @@ func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) { // mainCtrl.SimulateRestart(t) // xapp.Logger.Debug("mainCtrl.SimulateRestart done") - queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"}) // Delete subscription 2 @@ -4235,18 +4220,15 @@ func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) { func TestRESTReportSubReqAndSubDelOk(t *testing.T) { CaseBegin("TestRESTReportSubReqAndSubDelOk") subReqCount := 1 - parameterSet := 1 // E2SM-gNB-X2 - actionDefinitionPresent := true - actionParamCount := 1 testIndex := 1 - RESTReportSubReqAndSubDelOk(t, subReqCount, parameterSet, actionDefinitionPresent, actionParamCount, testIndex) + RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex) } -func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, parameterSet int, actionDefinitionPresent bool, actionParamCount int, testIndex int) { - xapp.Logger.Info("TEST: TestRESTReportSubReqAndSubDelOk with parameter set %v", testIndex) +func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) { + xapp.Logger.Info("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex) // Req - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) var e2SubsId []uint32 @@ -4288,25 +4270,21 @@ func TestRESTPolicySubReqAndSubDelOk(t *testing.T) { CaseBegin("TestRESTPolicySubReqAndSubDelOk") subReqCount := 2 - actionDefinitionPresent := true - policyParamCount := 1 testIndex := 1 - RESTPolicySubReqAndSubDelOk(t, subReqCount, actionDefinitionPresent, policyParamCount, testIndex) + RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex) subReqCount = 19 - actionDefinitionPresent = false - policyParamCount = 0 testIndex = 2 - RESTPolicySubReqAndSubDelOk(t, subReqCount, actionDefinitionPresent, policyParamCount, testIndex) + RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex) } */ -func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, actionDefinitionPresent bool, policyParamCount int, testIndex int) { - xapp.Logger.Info("TEST: TestRESTPolicySubReqAndSubDelOk with parameter set %v", testIndex) +func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) { + xapp.Logger.Info("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex) // Req - params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount) + params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) - //params := xappConn1.GetRESTSubsReqPolicyParams1(subReqCount, actionDefinitionPresent, policyParamCount) + //params := xappConn1.GetRESTSubsReqPolicyParams1(subReqCount) //restSubId := xappConn1.SendRESTPolicySubsReq(t, params) var e2SubsId []uint32 @@ -4336,7 +4314,6 @@ func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, actionDefinition mainCtrl.wait_registry_empty(t, 10) } -/* func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) { subReqCount := 2 @@ -4353,7 +4330,7 @@ func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) { }) // Req - params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount) + params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId) @@ -4369,8 +4346,6 @@ func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) { mainCtrl.VerifyCounterValues(t) } -*/ -/* func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) { subReqCount := 19 @@ -4387,7 +4362,7 @@ func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) { }) // Req - params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount) + params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId) @@ -4402,14 +4377,9 @@ func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) { mainCtrl.VerifyCounterValues(t) } -*/ -/* func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) { subReqCount := 2 - parameterSet := 1 - actionDefinitionPresent := true - actionParamCount := 1 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ Counter{cSubReqFromXapp, 1}, @@ -4423,7 +4393,7 @@ func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) { }) // Req - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId) @@ -4439,14 +4409,10 @@ func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) { mainCtrl.VerifyCounterValues(t) } -*/ -/* + func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) { subReqCount := 2 - parameterSet := 1 - actionDefinitionPresent := false - actionParamCount := 0 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ Counter{cSubReqFromXapp, 1}, @@ -4460,7 +4426,7 @@ func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) { }) // Req - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId) @@ -4476,14 +4442,10 @@ func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) { mainCtrl.VerifyCounterValues(t) } -*/ -/* + func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) { subReqCount := 19 - parameterSet := 1 - actionDefinitionPresent := false - actionParamCount := 0 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ Counter{cSubReqFromXapp, 1}, @@ -4497,7 +4459,7 @@ func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) { }) // Req - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId) @@ -4513,20 +4475,1260 @@ func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) { mainCtrl.VerifyCounterValues(t) } -*/ + +func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) { + CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cSubReqFromXapp, 2}, + Counter{cSubReqToE2, 2}, + Counter{cSubRespFromE2, 2}, + Counter{cSubRespToXapp, 2}, + Counter{cSubDelReqFromXapp, 2}, + Counter{cSubDelReqToE2, 2}, + Counter{cSubDelRespFromE2, 2}, + Counter{cSubDelRespToXapp, 2}, + }) + + // Req1 + var params *teststube2ap.RESTSubsReqParams = nil + + //Subs Create + restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) + xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1) + + queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"}) + + // Req2 + params = xappConn2.GetRESTSubsReqReportParams(subReqCount) + params.SetMeid("RAN_NAME_1") + eventTriggerDefinition := "1234" + params.SetSubEventTriggerDefinition(eventTriggerDefinition) + + restSubId2 := xappConn2.SendRESTSubsReq(t, params) + xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) + crereq, cremsg := e2termConn1.RecvSubsReq(t) + xappConn2.ExpectRESTNotification(t, restSubId2) + e2termConn1.SendSubsResp(t, crereq, cremsg) + e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) + + deleteXapp1Subscription(t, &restSubId1) + deleteXapp2Subscription(t, &restSubId2) + + waitSubsCleanup(t, e2SubsId1, 10) + waitSubsCleanup(t, e2SubsId2, 10) + + mainCtrl.VerifyCounterValues(t) + +} + +func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) { + CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cSubReqFromXapp, 2}, + Counter{cSubReqToE2, 2}, + Counter{cSubRespFromE2, 2}, + Counter{cSubRespToXapp, 2}, + Counter{cSubDelReqFromXapp, 2}, + Counter{cSubDelReqToE2, 2}, + Counter{cSubDelRespFromE2, 2}, + Counter{cSubDelRespToXapp, 2}, + }) + + // Req1 + var params *teststube2ap.RESTSubsReqParams = nil + + //Subs Create + restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) + xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1) + + queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"}) + + // Req2 + params = xappConn2.GetRESTSubsReqReportParams(subReqCount) + params.SetMeid("RAN_NAME_1") + + actionId := int64(1) + actionType := "report" + actionDefinition := "56781" + subsequestActionType := "continue" + timeToWait := "w10ms" + params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait) + + restSubId2 := xappConn2.SendRESTSubsReq(t, params) + xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) + crereq, cremsg := e2termConn1.RecvSubsReq(t) + xappConn2.ExpectRESTNotification(t, restSubId2) + e2termConn1.SendSubsResp(t, crereq, cremsg) + e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) + + deleteXapp1Subscription(t, &restSubId1) + deleteXapp2Subscription(t, &restSubId2) + + waitSubsCleanup(t, e2SubsId1, 10) + waitSubsCleanup(t, e2SubsId2, 10) + + mainCtrl.VerifyCounterValues(t) + +} + +func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) { + CaseBegin("TestRESTSubReqReportSameActionDiffActionID") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cSubReqFromXapp, 2}, + Counter{cSubReqToE2, 2}, + Counter{cSubRespFromE2, 2}, + Counter{cSubRespToXapp, 2}, + Counter{cSubDelReqFromXapp, 2}, + Counter{cSubDelReqToE2, 2}, + Counter{cSubDelRespFromE2, 2}, + Counter{cSubDelRespToXapp, 2}, + }) + + // Req1 + var params *teststube2ap.RESTSubsReqParams = nil + + //Subs Create + restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) + xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1) + + queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"}) + + // Req2 + params = xappConn2.GetRESTSubsReqReportParams(subReqCount) + params.SetMeid("RAN_NAME_1") + params.SetSubActionIDs(int64(2)) + + restSubId2 := xappConn2.SendRESTSubsReq(t, params) + xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) + crereq, cremsg := e2termConn1.RecvSubsReq(t) + xappConn2.ExpectRESTNotification(t, restSubId2) + e2termConn1.SendSubsResp(t, crereq, cremsg) + e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) + + deleteXapp1Subscription(t, &restSubId1) + deleteXapp2Subscription(t, &restSubId2) + + waitSubsCleanup(t, e2SubsId1, 10) + waitSubsCleanup(t, e2SubsId2, 10) + + mainCtrl.VerifyCounterValues(t) + +} + +func TestRESTSubReqDiffActionType(t *testing.T) { + CaseBegin("TestRESTSubReqDiffActionType") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cSubReqFromXapp, 2}, + Counter{cSubReqToE2, 2}, + Counter{cSubRespFromE2, 2}, + Counter{cSubRespToXapp, 2}, + Counter{cSubDelReqFromXapp, 2}, + Counter{cSubDelReqToE2, 2}, + Counter{cSubDelRespFromE2, 2}, + Counter{cSubDelRespToXapp, 2}, + }) + + // Req1 + params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) + + //Subs Create + restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) + xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1) + + queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"}) + + // Req2 + params = xappConn2.GetRESTSubsReqReportParams(subReqCount) + params.SetMeid("RAN_NAME_1") + + restSubId2 := xappConn2.SendRESTSubsReq(t, params) + xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) + crereq, cremsg := e2termConn1.RecvSubsReq(t) + xappConn2.ExpectRESTNotification(t, restSubId2) + e2termConn1.SendSubsResp(t, crereq, cremsg) + e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) + + deleteXapp1Subscription(t, &restSubId1) + deleteXapp2Subscription(t, &restSubId2) + + waitSubsCleanup(t, e2SubsId1, 10) + waitSubsCleanup(t, e2SubsId2, 10) + + mainCtrl.VerifyCounterValues(t) + +} + +func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) { + CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cSubReqFromXapp, 2}, + Counter{cSubReqToE2, 2}, + Counter{cSubRespFromE2, 2}, + Counter{cSubRespToXapp, 2}, + Counter{cSubDelReqFromXapp, 2}, + Counter{cSubDelReqToE2, 2}, + Counter{cSubDelRespFromE2, 2}, + Counter{cSubDelRespToXapp, 2}, + }) + + // Req1 + params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) + + //Subs Create + restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) + xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1) + + queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"}) + + // Req2 + params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount) + params.SetMeid("RAN_NAME_1") + + restSubId2 := xappConn2.SendRESTSubsReq(t, params) + xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) + crereq, cremsg := e2termConn1.RecvSubsReq(t) + xappConn2.ExpectRESTNotification(t, restSubId2) + e2termConn1.SendSubsResp(t, crereq, cremsg) + e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) + + deleteXapp1Subscription(t, &restSubId1) + deleteXapp2Subscription(t, &restSubId2) + + waitSubsCleanup(t, e2SubsId1, 10) + waitSubsCleanup(t, e2SubsId2, 10) + + mainCtrl.VerifyCounterValues(t) + +} + +func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) { + CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cSubReqFromXapp, 2}, + Counter{cSubReqToE2, 2}, + Counter{cSubRespFromE2, 2}, + Counter{cSubRespToXapp, 2}, + Counter{cSubDelReqFromXapp, 2}, + Counter{cSubDelReqToE2, 2}, + Counter{cSubDelRespFromE2, 2}, + Counter{cSubDelRespToXapp, 2}, + }) + + // Req1 + var params *teststube2ap.RESTSubsReqParams = nil + + //Subs Create + restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) + xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1) + + queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"}) + + // Req2 + params = xappConn2.GetRESTSubsReqReportParams(subReqCount) + params.SetMeid("RAN_NAME_1") + actionDefinition := "5678" + params.SetSubActionDefinition(actionDefinition) + + restSubId2 := xappConn2.SendRESTSubsReq(t, params) + xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) + crereq, cremsg := e2termConn1.RecvSubsReq(t) + xappConn2.ExpectRESTNotification(t, restSubId2) + e2termConn1.SendSubsResp(t, crereq, cremsg) + e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) + + deleteXapp1Subscription(t, &restSubId1) + deleteXapp2Subscription(t, &restSubId2) + + waitSubsCleanup(t, e2SubsId1, 10) + waitSubsCleanup(t, e2SubsId2, 10) + + mainCtrl.VerifyCounterValues(t) + +} + +func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) { + CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cSubReqFromXapp, 2}, + Counter{cSubReqToE2, 2}, + Counter{cSubRespFromE2, 2}, + Counter{cSubRespToXapp, 2}, + Counter{cSubDelReqFromXapp, 2}, + Counter{cSubDelReqToE2, 2}, + Counter{cSubDelRespFromE2, 2}, + Counter{cSubDelRespToXapp, 2}, + }) + + // Req1 + var params *teststube2ap.RESTSubsReqParams = nil + + //Subs Create + restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) + xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1) + + queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"}) + + // Req2 + params = xappConn2.GetRESTSubsReqReportParams(subReqCount) + params.SetMeid("RAN_NAME_1") + actionDefinition := "56782" + params.SetSubActionDefinition(actionDefinition) + + restSubId2 := xappConn2.SendRESTSubsReq(t, params) + xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) + crereq, cremsg := e2termConn1.RecvSubsReq(t) + xappConn2.ExpectRESTNotification(t, restSubId2) + e2termConn1.SendSubsResp(t, crereq, cremsg) + e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) + + deleteXapp1Subscription(t, &restSubId1) + deleteXapp2Subscription(t, &restSubId2) + + waitSubsCleanup(t, e2SubsId1, 10) + waitSubsCleanup(t, e2SubsId2, 10) + + mainCtrl.VerifyCounterValues(t) + +} + +func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) { + CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cSubReqFromXapp, 2}, + Counter{cSubReqToE2, 2}, + Counter{cSubRespFromE2, 2}, + Counter{cSubRespToXapp, 2}, + Counter{cSubDelReqFromXapp, 2}, + Counter{cSubDelReqToE2, 2}, + Counter{cSubDelRespFromE2, 2}, + Counter{cSubDelRespToXapp, 2}, + }) + + // Req1 + var params *teststube2ap.RESTSubsReqParams = nil + + //Subs Create + restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) + xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1) + + queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"}) + + // Req2 + params = xappConn2.GetRESTSubsReqReportParams(subReqCount) + params.SetMeid("RAN_NAME_1") + params.SetTimeToWait("w200ms") + restSubId2 := xappConn2.SendRESTSubsReq(t, params) + xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) + crereq, cremsg := e2termConn1.RecvSubsReq(t) + xappConn2.ExpectRESTNotification(t, restSubId2) + e2termConn1.SendSubsResp(t, crereq, cremsg) + e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) + + deleteXapp1Subscription(t, &restSubId1) + deleteXapp2Subscription(t, &restSubId2) + + waitSubsCleanup(t, e2SubsId1, 10) + waitSubsCleanup(t, e2SubsId2, 10) + + mainCtrl.VerifyCounterValues(t) + +} + +//----------------------------------------------------------------------------- +// TestRESTUnpackSubscriptionResponseDecodeFail +// +// stub stub +// +-------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | +// +-------+ +---------+ +---------+ +// | | | +// | RestSubReq | | +// |---------------->| | +// | | | +// | RESTSubResp | | +// |<----------------| | +// | | | +// | | SubReq | +// | |------------->| +// | | | +// | | SubResp | ASN.1 decode fails +// | |<-------------| +// | | | +// | | SubReq | +// | |------------->| +// | | | +// | | SubFail | Duplicated action +// | |<-------------| +// | RESTNotif (fail)| | +// |<----------------| | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelResp | +// | |<-------------| +// +//----------------------------------------------------------------------------- +func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) { + xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseDecodeFail") + subReqCount := 1 + + // Req + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) + restSubId := xappConn1.SendRESTSubsReq(t, params) + + crereq, cremsg := e2termConn1.RecvSubsReq(t) + // Decode of this response fails which will result resending original request + e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP) + + _, cremsg = e2termConn1.RecvSubsReq(t) + + xappConn1.ExpectRESTNotification(t, restSubId) + + // Subscription already created in E2 Node. + fparams := &teststube2ap.E2StubSubsFailParams{} + fparams.Set(crereq) + fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action + e2termConn1.SendSubsFail(t, fparams, cremsg) + + delreq, delmsg := e2termConn1.RecvSubsDelReq(t) + e2termConn1.SendSubsDelResp(t, delreq, delmsg) + + instanceId := xappConn1.WaitRESTNotification(t, restSubId) + xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId) + + // Wait that subs is cleaned + mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10) + + xappConn1.TestMsgChanEmpty(t) + e2termConn1.TestMsgChanEmpty(t) + mainCtrl.wait_registry_empty(t, 10) +} + +//----------------------------------------------------------------------------- +// TestRESTUnpackSubscriptionResponseUnknownInstanceId +// +// stub stub +// +-------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | +// +-------+ +---------+ +---------+ +// | | | +// | RestSubReq | | +// |---------------->| | +// | | | +// | RESTSubResp | | +// |<----------------| | +// | | | +// | | SubReq | +// | |------------->| +// | | | +// | | SubResp | Unknown instanceId +// | |<-------------| +// | | | +// | | SubReq | +// | |------------->| +// | | | +// | | SubFail | Duplicated action +// | |<-------------| +// | RESTNotif (fail)| | +// |<----------------| | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelResp | +// | |<-------------| +// +//----------------------------------------------------------------------------- +func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) { + xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId") + subReqCount := 1 + + // Req + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) + restSubId := xappConn1.SendRESTSubsReq(t, params) + + crereq, cremsg := e2termConn1.RecvSubsReq(t) + + // Unknown instanceId in this response which will result resending original request + orgInstanceId := crereq.RequestId.InstanceId + crereq.RequestId.InstanceId = 0 + e2termConn1.SendSubsResp(t, crereq, cremsg) + + _, cremsg = e2termConn1.RecvSubsReq(t) + + xappConn1.ExpectRESTNotification(t, restSubId) + + // Subscription already created in E2 Node. + fparams := &teststube2ap.E2StubSubsFailParams{} + fparams.Set(crereq) + fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action + e2termConn1.SendSubsFail(t, fparams, cremsg) + + delreq, delmsg := e2termConn1.RecvSubsDelReq(t) + e2termConn1.SendSubsDelResp(t, delreq, delmsg) + + instanceId := xappConn1.WaitRESTNotification(t, restSubId) + xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId) + + // Wait that subs is cleaned + mainCtrl.wait_subs_clean(t, orgInstanceId, 10) + + xappConn1.TestMsgChanEmpty(t) + e2termConn1.TestMsgChanEmpty(t) + mainCtrl.wait_registry_empty(t, 10) +} + +//----------------------------------------------------------------------------- +// TestRESTUnpackSubscriptionResponseNoTransaction +// +// stub stub +// +-------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | +// +-------+ +---------+ +---------+ +// | | | +// | RestSubReq | | +// |---------------->| | +// | | | +// | RESTSubResp | | +// |<----------------| | +// | | | +// | | SubReq | +// | |------------->| +// | | | +// | | SubResp | No transaction for the response +// | |<-------------| +// | | | +// | | SubReq | +// | |------------->| +// | | | +// | | SubFail | Duplicated action +// | |<-------------| +// | RESTNotif (fail)| | +// |<----------------| | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelResp | +// | |<-------------| +// | | | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelResp | +// | |<-------------| +// +//----------------------------------------------------------------------------- +func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) { + xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseNoTransaction") + subReqCount := 1 + + // Req + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) + restSubId := xappConn1.SendRESTSubsReq(t, params) + + crereq, cremsg := e2termConn1.RecvSubsReq(t) + + mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId) + // No transaction exist for this response which will result resending original request + e2termConn1.SendSubsResp(t, crereq, cremsg) + + _, cremsg = e2termConn1.RecvSubsReq(t) + + xappConn1.ExpectRESTNotification(t, restSubId) + + // Subscription already created in E2 Node. + fparams := &teststube2ap.E2StubSubsFailParams{} + fparams.Set(crereq) + fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action + e2termConn1.SendSubsFail(t, fparams, cremsg) + + delreq, delmsg := e2termConn1.RecvSubsDelReq(t) + e2termConn1.SendSubsDelResp(t, delreq, delmsg) + + // Resending happens because there no transaction + delreq, delmsg = e2termConn1.RecvSubsDelReq(t) + e2termConn1.SendSubsDelResp(t, delreq, delmsg) + + instanceId := xappConn1.WaitRESTNotification(t, restSubId) + xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId) + + // Wait that subs is cleaned + mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10) + + xappConn1.TestMsgChanEmpty(t) + e2termConn1.TestMsgChanEmpty(t) + mainCtrl.wait_registry_empty(t, 10) + +} + +//----------------------------------------------------------------------------- +// TestRESTUnpackSubscriptionFailureDecodeFail +// +// stub stub +// +-------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | +// +-------+ +---------+ +---------+ +// | | | +// | RestSubReq | | +// |---------------->| | +// | | | +// | RESTSubResp | | +// |<----------------| | +// | | | +// | | SubReq | +// | |------------->| +// | | | +// | | SubFail | ASN.1 decode fails +// | |<-------------| +// | | | +// | | SubReq | +// | |------------->| +// | | | +// | | SubFail | Duplicated action +// | |<-------------| +// | RESTNotif (fail)| | +// |<----------------| | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelResp | +// | |<-------------| +// +//----------------------------------------------------------------------------- +func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) { + xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureDecodeFail") + subReqCount := 1 + + // Req + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) + restSubId := xappConn1.SendRESTSubsReq(t, params) + + crereq, cremsg := e2termConn1.RecvSubsReq(t) + + // Decode of this response fails which will result resending original request + e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE) + + _, cremsg = e2termConn1.RecvSubsReq(t) + + xappConn1.ExpectRESTNotification(t, restSubId) + + // Subscription already created in E2 Node. + fparams := &teststube2ap.E2StubSubsFailParams{} + fparams.Set(crereq) + fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action + e2termConn1.SendSubsFail(t, fparams, cremsg) + + delreq, delmsg := e2termConn1.RecvSubsDelReq(t) + e2termConn1.SendSubsDelResp(t, delreq, delmsg) + + instanceId := xappConn1.WaitRESTNotification(t, restSubId) + xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId) + + // Wait that subs is cleaned + mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10) + + xappConn1.TestMsgChanEmpty(t) + e2termConn1.TestMsgChanEmpty(t) + mainCtrl.wait_registry_empty(t, 10) +} + +//----------------------------------------------------------------------------- +// TestRESTUnpackSubscriptionResponseUnknownInstanceId +// +// stub stub +// +-------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | +// +-------+ +---------+ +---------+ +// | | | +// | RestSubReq | | +// |---------------->| | +// | | | +// | RESTSubResp | | +// |<----------------| | +// | | | +// | | SubReq | +// | |------------->| +// | | | +// | | SubFail | Unknown instanceId +// | |<-------------| +// | | | +// | | SubReq | +// | |------------->| +// | | | +// | | SubFail | Duplicated action +// | |<-------------| +// | RESTNotif (fail)| | +// |<----------------| | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelResp | +// | |<-------------| +// +//----------------------------------------------------------------------------- +func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) { + xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId") + subReqCount := 1 + + // Req + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) + restSubId := xappConn1.SendRESTSubsReq(t, params) + + crereq, cremsg := e2termConn1.RecvSubsReq(t) + + // Unknown instanceId in this response which will result resending original request + fparams := &teststube2ap.E2StubSubsFailParams{} + fparams.Set(crereq) + fparams.Fail.RequestId.InstanceId = 0 + e2termConn1.SendSubsFail(t, fparams, cremsg) + + _, cremsg = e2termConn1.RecvSubsReq(t) + + xappConn1.ExpectRESTNotification(t, restSubId) + + // Subscription already created in E2 Node. + fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action + e2termConn1.SendSubsFail(t, fparams, cremsg) + + delreq, delmsg := e2termConn1.RecvSubsDelReq(t) + e2termConn1.SendSubsDelResp(t, delreq, delmsg) + + instanceId := xappConn1.WaitRESTNotification(t, restSubId) + xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId) + + // Wait that subs is cleaned + mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10) + + xappConn1.TestMsgChanEmpty(t) + e2termConn1.TestMsgChanEmpty(t) + mainCtrl.wait_registry_empty(t, 10) +} + +//----------------------------------------------------------------------------- +// TestRESTUnpackSubscriptionFailureNoTransaction +// +// stub stub +// +-------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | +// +-------+ +---------+ +---------+ +// | | | +// | RestSubReq | | +// |---------------->| | +// | | | +// | RESTSubResp | | +// |<----------------| | +// | | | +// | | SubReq | +// | |------------->| +// | | | +// | | SubFail | No transaction for the response +// | |<-------------| +// | | | +// | | SubReq | +// | |------------->| +// | | | +// | | SubFail | Duplicated action +// | |<-------------| +// | RESTNotif (fail)| | +// |<----------------| | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelResp | +// | |<-------------| +// +//----------------------------------------------------------------------------- +func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) { + xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureNoTransaction") + subReqCount := 1 + + // Req + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) + restSubId := xappConn1.SendRESTSubsReq(t, params) + + crereq, cremsg := e2termConn1.RecvSubsReq(t) + + mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId) + + // No transaction exist for this response which will result resending original request + fparams := &teststube2ap.E2StubSubsFailParams{} + fparams.Set(crereq) + e2termConn1.SendSubsFail(t, fparams, cremsg) + + _, cremsg = e2termConn1.RecvSubsReq(t) + + xappConn1.ExpectRESTNotification(t, restSubId) + + // Subscription already created in E2 Node. + fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action + e2termConn1.SendSubsFail(t, fparams, cremsg) + + delreq, delmsg := e2termConn1.RecvSubsDelReq(t) + e2termConn1.SendSubsDelResp(t, delreq, delmsg) + + // Resending happens because there no transaction + delreq, delmsg = e2termConn1.RecvSubsDelReq(t) + e2termConn1.SendSubsDelResp(t, delreq, delmsg) + + instanceId := xappConn1.WaitRESTNotification(t, restSubId) + xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId) + + // Wait that subs is cleaned + mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10) + + xappConn1.TestMsgChanEmpty(t) + e2termConn1.TestMsgChanEmpty(t) + mainCtrl.wait_registry_empty(t, 10) +} + +//----------------------------------------------------------------------------- +// TestRESTUnpackSubscriptionDeleteResponseDecodeFail +// +// stub stub +// +-------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | +// +-------+ +---------+ +---------+ +// | | | +// | [SUBS CREATE] | +// | | | +// | | | +// | RESTSubDelReq | | +// |---------------->| | +// | | | +// | RESTSubDelResp | | +// |<----------------| | +// | | | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelResp | ASN.1 decode fails +// | |<-------------| +// | | | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelFail | Subscription does exist any more +// | |<-------------| +// | | | +// +//----------------------------------------------------------------------------- +func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) { + xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail") + + // Req + var params *teststube2ap.RESTSubsReqParams = nil + restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) + + // Del + xappConn1.SendRESTSubsDelReq(t, &restSubId) + + // E2t: Receive 1st SubsDelReq + delreq, delmsg := e2termConn1.RecvSubsDelReq(t) + + // Decode of this response fails which will result resending original request + e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_REQ) + + // E2t: Receive 2nd SubsDelReq and send SubsDelResp + delreq, delmsg = e2termConn1.RecvSubsDelReq(t) + + // Subscription does not exist in in E2 Node. + e2termConn1.SendSubsDelFail(t, delreq, delmsg) + + // Wait that subs is cleaned + mainCtrl.wait_subs_clean(t, e2SubsId, 10) + + xappConn1.TestMsgChanEmpty(t) + e2termConn1.TestMsgChanEmpty(t) + mainCtrl.wait_registry_empty(t, 10) +} + +//----------------------------------------------------------------------------- +// TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId +// +// stub stub +// +-------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | +// +-------+ +---------+ +---------+ +// | | | +// | [SUBS CREATE] | +// | | | +// | | | +// | RESTSubDelReq | | +// |---------------->| | +// | | | +// | RESTSubDelResp | | +// |<----------------| | +// | | | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelResp | Unknown instanceId +// | |<-------------| +// | | | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelFail | Subscription does exist any more +// | |<-------------| +// +//----------------------------------------------------------------------------- +func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) { + xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId") + + // Req + var params *teststube2ap.RESTSubsReqParams = nil + restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) + + // Del + xappConn1.SendRESTSubsDelReq(t, &restSubId) + + // E2t: Receive 1st SubsDelReq + delreq, delmsg := e2termConn1.RecvSubsDelReq(t) + + // Unknown instanceId in this response which will result resending original request + delreq.RequestId.InstanceId = 0 + e2termConn1.SendSubsDelResp(t, delreq, delmsg) + + // E2t: Receive 2nd SubsDelReq + delreq, delmsg = e2termConn1.RecvSubsDelReq(t) + + // Subscription does not exist in in E2 Node. + e2termConn1.SendSubsDelFail(t, delreq, delmsg) + + // Wait that subs is cleaned + mainCtrl.wait_subs_clean(t, e2SubsId, 10) + + xappConn1.TestMsgChanEmpty(t) + e2termConn1.TestMsgChanEmpty(t) + mainCtrl.wait_registry_empty(t, 10) +} + +//----------------------------------------------------------------------------- +// TestRESTUnpackSubscriptionDeleteResponseNoTransaction +// +// stub stub +// +-------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | +// +-------+ +---------+ +---------+ +// | | | +// | [SUBS CREATE] | +// | | | +// | | | +// | RESTSubDelReq | | +// |---------------->| | +// | | | +// | RESTSubDelResp | | +// |<----------------| | +// | | | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelResp | No transaction for the response +// | |<-------------| +// | | | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelFail | Subscription does exist any more +// | |<-------------| +// +//----------------------------------------------------------------------------- +func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) { + xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction") + + // Req + var params *teststube2ap.RESTSubsReqParams = nil + restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) + + // Del + xappConn1.SendRESTSubsDelReq(t, &restSubId) + + // E2t: Receive 1st SubsDelReq + delreq, delmsg := e2termConn1.RecvSubsDelReq(t) + + mainCtrl.MakeTransactionNil(t, e2SubsId) + + // No transaction exist for this response which will result resending original request + e2termConn1.SendSubsDelResp(t, delreq, delmsg) + + // E2t: Receive 2nd SubsDelReq + delreq, delmsg = e2termConn1.RecvSubsDelReq(t) + + // Subscription does not exist in in E2 Node. + e2termConn1.SendSubsDelFail(t, delreq, delmsg) + + // Wait that subs is cleaned + mainCtrl.wait_subs_clean(t, e2SubsId, 10) + + xappConn1.TestMsgChanEmpty(t) + e2termConn1.TestMsgChanEmpty(t) + mainCtrl.wait_registry_empty(t, 10) +} + +//----------------------------------------------------------------------------- +// TestRESTUnpackSubscriptionDeleteFailureDecodeFail +// +// stub stub +// +-------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | +// +-------+ +---------+ +---------+ +// | | | +// | [SUBS CREATE] | +// | | | +// | | | +// | RESTSubDelReq | | +// |---------------->| | +// | | | +// | RESTSubDelResp | | +// |<----------------| | +// | | | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelFail | ASN.1 decode fails +// | |<-------------| +// | | | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelFail | Subscription does exist any more +// | |<-------------| +// +//----------------------------------------------------------------------------- +func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) { + xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail") + + // Req + var params *teststube2ap.RESTSubsReqParams = nil + restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) + + // Del + xappConn1.SendRESTSubsDelReq(t, &restSubId) + + // E2t: Receive 1st SubsDelReq + delreq, delmsg := e2termConn1.RecvSubsDelReq(t) + + // Decode of this response fails which will result resending original request + e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE) + + // E2t: Receive 2nd SubsDelReq and send SubsDelResp + delreq, delmsg = e2termConn1.RecvSubsDelReq(t) + + // Subscription does not exist in in E2 Node. + e2termConn1.SendSubsDelFail(t, delreq, delmsg) + + // Wait that subs is cleaned + mainCtrl.wait_subs_clean(t, e2SubsId, 10) + + xappConn1.TestMsgChanEmpty(t) + e2termConn1.TestMsgChanEmpty(t) + mainCtrl.wait_registry_empty(t, 10) +} + +//----------------------------------------------------------------------------- +// TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId +// +// stub stub +// +-------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | +// +-------+ +---------+ +---------+ +// | | | +// | [SUBS CREATE] | +// | | | +// | | | +// | RESTSubDelReq | | +// |---------------->| | +// | | | +// | RESTSubDelResp | | +// |<----------------| | +// | | | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelFail | Unknown instanceId +// | |<-------------| +// | | | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelFail | Subscription does exist any more +// | |<-------------| +// +//----------------------------------------------------------------------------- +func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) { + xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId") + + // Req + var params *teststube2ap.RESTSubsReqParams = nil + restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) + + // Del + xappConn1.SendRESTSubsDelReq(t, &restSubId) + + // E2t: Receive 1st SubsDelReq + delreq, delmsg := e2termConn1.RecvSubsDelReq(t) + + // Unknown instanceId in this response which will result resending original request + delreq.RequestId.InstanceId = 0 + e2termConn1.SendSubsDelFail(t, delreq, delmsg) + + // E2t: Receive 2nd SubsDelReq + delreq, delmsg = e2termConn1.RecvSubsDelReq(t) + + // Subscription does not exist in in E2 Node. + e2termConn1.SendSubsDelFail(t, delreq, delmsg) + + // Wait that subs is cleaned + mainCtrl.wait_subs_clean(t, e2SubsId, 10) + + xappConn1.TestMsgChanEmpty(t) + e2termConn1.TestMsgChanEmpty(t) + mainCtrl.wait_registry_empty(t, 10) +} + +//----------------------------------------------------------------------------- +// TestRESTUnpackSubscriptionDeleteFailureNoTransaction +// +// stub stub +// +-------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | +// +-------+ +---------+ +---------+ +// | | | +// | [SUBS CREATE] | +// | | | +// | | | +// | RESTSubDelReq | | +// |---------------->| | +// | | | +// | RESTSubDelResp | | +// |<----------------| | +// | | | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelFail | No transaction for the response +// | |<-------------| +// | | | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelFail | Subscription does exist any more +// | |<-------------| +// +//----------------------------------------------------------------------------- +func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) { + xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction") + + // Req + var params *teststube2ap.RESTSubsReqParams = nil + restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) + + // Del + xappConn1.SendRESTSubsDelReq(t, &restSubId) + + // E2t: Receive 1st SubsDelReq + delreq, delmsg := e2termConn1.RecvSubsDelReq(t) + + mainCtrl.MakeTransactionNil(t, e2SubsId) + + // No transaction exist for this response which will result resending original request + e2termConn1.SendSubsDelFail(t, delreq, delmsg) + + // E2t: Receive 2nd SubsDelReq + delreq, delmsg = e2termConn1.RecvSubsDelReq(t) + + // Subscription does not exist in in E2 Node. + e2termConn1.SendSubsDelFail(t, delreq, delmsg) + + // Wait that subs is cleaned + mainCtrl.wait_subs_clean(t, e2SubsId, 10) + + xappConn1.TestMsgChanEmpty(t) + e2termConn1.TestMsgChanEmpty(t) + mainCtrl.wait_registry_empty(t, 10) +} + +//----------------------------------------------------------------------------- +// TestRESTSubReqFailAsn1PackSubReqError +// +// stub stub +// +-------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | +// +-------+ +---------+ +---------+ +// | | | +// | RESTSubReq | | +// |---------------->| | +// | | | +// | RESTSubResp | | +// |<----------------| | +// | | | +// | ASN.1 encode fails | +// | | | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelFail | +// | |<-------------| +// | | | +// | RESTNotif | | +// | unsuccess | | +// |<----------------| | +// | | | +// | [SUBS DELETE] | +// | | | +// +//----------------------------------------------------------------------------- +func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) { + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cSubReqFromXapp, 1}, + Counter{cSubDelReqToE2, 1}, + Counter{cSubDelFailFromE2, 1}, + Counter{cSubRespToXapp, 1}, + }) + + subReqCount := 1 + + var params *teststube2ap.RESTSubsReqParams = nil + params = xappConn1.GetRESTSubsReqReportParams(subReqCount) + e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false) + + // Req + restSubId := xappConn1.SendRESTSubsReq(t, params) + xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId) + + // E2t: Receive SubsDelReq + delreq, delmsg := e2termConn1.RecvSubsDelReq(t) + xappConn1.ExpectRESTNotification(t, restSubId) + + // Subscription does not exist in in E2 Node. + e2termConn1.SendSubsDelFail(t, delreq, delmsg) + + e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) + xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId) + + e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true) + // Wait that subs is cleaned + waitSubsCleanup(t, e2SubsId, 10) + mainCtrl.VerifyCounterValues(t) +} + //////////////////////////////////////////////////////////////////////////////////// // Services for UT cases //////////////////////////////////////////////////////////////////////////////////// const subReqCount int = 1 -const parameterSet = 1 -const actionDefinitionPresent bool = true -const actionParamCount int = 1 -const policyParamCount int = 1 const host string = "localhost" func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) { if params == nil { - params = fromXappConn.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params = fromXappConn.GetRESTSubsReqReportParams(subReqCount) } restSubId := fromXappConn.SendRESTSubsReq(t, params) xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId) @@ -4542,7 +5744,7 @@ func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2ter func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) { - params := xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn2.GetRESTSubsReqReportParams(subReqCount) if meid != "" { params.SetMeid(meid) } @@ -4557,7 +5759,7 @@ func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) { } func createXapp1PolicySubscription(t *testing.T) (string, uint32) { - params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount) + params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId) @@ -4571,7 +5773,7 @@ func createXapp1PolicySubscription(t *testing.T) (string, uint32) { } func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) { - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)