X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=pkg%2Fcontrol%2Fut_messaging_test.go;h=2c905137e3a761e8a8e8154a0ca47b06702e1087;hb=93a5f9e27a6803adce055811c222632bfd69d11c;hp=e3d6655649d27079be71c95ca7328033b3a741da;hpb=5112239fe7bf1a53f43d8898d2862921594b1f80;p=ric-plt%2Fsubmgr.git diff --git a/pkg/control/ut_messaging_test.go b/pkg/control/ut_messaging_test.go index e3d6655..2c90513 100644 --- a/pkg/control/ut_messaging_test.go +++ b/pkg/control/ut_messaging_test.go @@ -20,30 +20,464 @@ package control import ( + //"os" + "strings" "testing" "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/nodeb-rnib.git/entities" "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: +func TestSuiteSetup(t *testing.T) { + // The effect of this call shall endure though the UT suite! + // If this causes any issues, the previous interface can be restored + // like this:git log // SetPackerIf(e2ap_wrapper.NewAsn1E2APPacker()) + mainCtrl.InitAllCounterMap() SetPackerIf(e2ap_wrapper.NewUtAsn1E2APPacker()) + mainCtrl.c.restDuplicateCtrl.Init() + +} +func TestRanStatusChangeViaSDLNotification(t *testing.T) { + + // Current UT test cases use these ran names + xappRnibMock.CreateGnb("RAN_NAME_1", entities.ConnectionStatus_DISCONNECTED) + xappRnibMock.CreateGnb("RAN_NAME_11", entities.ConnectionStatus_DISCONNECTED) + xappRnibMock.CreateGnb("RAN_NAME_2", entities.ConnectionStatus_DISCONNECTED) + + mainCtrl.c.e2IfState.ReadE2ConfigurationFromRnib() + mainCtrl.c.e2IfState.SubscribeChannels() + + mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED") + mainCtrl.SetE2State(t, "RAN_NAME_2_CONNECTED") + mainCtrl.SetE2State(t, "RAN_NAME_11_CONNECTED") +} + +//----------------------------------------------------------------------------- +// TestRESTSubReqAfterE2ConnBreak +// +// stub stub +// +-------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | +// +-------+ +---------+ +---------+ +// | | | +// | [E2 Conn. DOWN] | +// | | | +// | RESTSubReq | | +// |---------------->| | +// | RESTSubFail | | +// |<----------------| | +// | | | +// +//----------------------------------------------------------------------------- + +func TestRESTSubReqAfterE2ConnBreak(t *testing.T) { + CaseBegin("TestRESTSubReqAfterE2ConnBreak") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestReqRejDueE2Down, 1}, + }) + + // E2 disconnect after E2term has received response + mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED") + // Req + const subReqCount int = 1 + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) + xappConn1.SendRESTSubsReq(t, params) + + // Restore E2 connection for following test cases + mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED") + + mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) + //os.Exit(0) +} + +//----------------------------------------------------------------------------- +// TestRESTSubReqE2ConnBreak +// +// stub stub +// +-------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | +// +-------+ +---------+ +---------+ +// | | | +// | RESTSubReq | | +// |---------------->| | +// | RESTSubResp | | +// |<----------------| | +// | | SubReq | +// | |------------->| +// | | SubResp | +// | |<-------------| +// | | | +// | [E2 Conn. DOWN] | +// | [Int. SUBS DELETE] | +// | | | +// | RESTNotif(unsuccessful) | +// |<----------------| | +// | | | +// | | | +// +//----------------------------------------------------------------------------- +func TestRESTSubReqE2ConnBreak(t *testing.T) { + CaseBegin("TestRESTSubReqE2ConnBreak") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, + Counter{cSubReqToE2, 1}, + Counter{cSubRespFromE2, 1}, + Counter{cRestSubFailNotifToXapp, 1}, + }) + + // Req + const subReqCount int = 1 + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) + restSubId := xappConn1.SendRESTSubsReq(t, params) + + crereq, cremsg := e2termConn1.RecvSubsReq(t) + xappConn1.ExpectRESTNotification(t, restSubId) + + // E2 disconnect after E2term has received response + mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED") + + e2termConn1.SendSubsResp(t, crereq, cremsg) + e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) + + <-time.After(time.Second * 1) + assert.Equal(t, 0, len(mainCtrl.c.registry.register)) + assert.Equal(t, 0, len(mainCtrl.c.registry.restSubscriptions)) + + subIds, register, err := mainCtrl.c.ReadAllSubscriptionsFromSdl() + if err != nil { + xapp.Logger.Error("%v", err) + } else { + assert.Equal(t, 65534, len(subIds)) // range 1-65535 , FFFF = 65535 + assert.Equal(t, 0, len(register)) + } + + restSubscriptions, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl() + if err != nil { + xapp.Logger.Error("%v", err) + } else { + assert.Equal(t, 0, len(restSubscriptions)) + } + + // Restore E2 connection for following test cases + mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED") + + // Wait that subs is cleaned + waitSubsCleanup(t, e2SubsId, 10) + mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) +} + +//----------------------------------------------------------------------------- +// TestRESTSubscriptionDeleteAfterE2ConnectionBreak +// +// stub stub +// +-------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | +// +-------+ +---------+ +---------+ +// | | | +// | [SUBS CREATE] | +// | | | +// | [E2 Conn. DOWN] | +// | | | +// | RESTSubDelReq | | +// |---------------->| | +// | | | +// | RESTSubDelResp | | +// |<----------------| | +// | | | +// | [No valid subscription found] | +// | | | +// +//----------------------------------------------------------------------------- +func TestRESTSubscriptionDeleteAfterE2ConnectionBreak(t *testing.T) { + xapp.Logger.Debug("TEST: TestRESTSubscriptionDeleteAfterE2ConnectionBreak") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, + Counter{cSubReqToE2, 1}, + Counter{cSubRespFromE2, 1}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, + }) + + // Req + var params *teststube2ap.RESTSubsReqParams = nil + restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) + + // E2 disconnect after E2term has received response + mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED") + + // Del + xappConn1.SendRESTSubsDelReq(t, &restSubId) + + <-time.After(time.Second * 1) + assert.Equal(t, 0, len(mainCtrl.c.registry.register)) + assert.Equal(t, 0, len(mainCtrl.c.registry.restSubscriptions)) + + subIds, register, err := mainCtrl.c.ReadAllSubscriptionsFromSdl() + if err != nil { + xapp.Logger.Error("%v", err) + } else { + assert.Equal(t, 65534, len(subIds)) // range 1-65535 , FFFF = 65535 + assert.Equal(t, 0, len(register)) + } + + restSubscriptions, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl() + if err != nil { + xapp.Logger.Error("%v", err) + } else { + assert.Equal(t, 0, len(restSubscriptions)) + } + + // Restore E2 connection for following test cases + mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED") + + // Wait that subs is cleaned + mainCtrl.wait_subs_clean(t, e2SubsId, 10) + + xappConn1.TestMsgChanEmpty(t) + e2termConn1.TestMsgChanEmpty(t) + mainCtrl.wait_registry_empty(t, 10) + mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) +} + +//----------------------------------------------------------------------------- +// TestRESTOtherE2ConnectionChanges +// + +// stub stub +// +-------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | +// +-------+ +---------+ +---------+ +// | | | +// | [SUBS CREATE] | +// | | | +// | [E2 CONNECTED_SETUP_FAILED] | +// | [E2 CONNECTING] | +// | [E2 SHUTTING_DOWN] | +// | [E2 SHUT_DOWN] | +// | | | +// | [SUBS DELETE] | +// | | | +// +//----------------------------------------------------------------------------- +func TestRESTOtherE2ConnectionChanges(t *testing.T) { + xapp.Logger.Debug("TEST: TestRESTOtherE2ConnectionChanges") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, + Counter{cSubReqToE2, 1}, + Counter{cSubRespFromE2, 1}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cSubDelReqToE2, 1}, + Counter{cSubDelRespFromE2, 1}, + Counter{cRestSubDelRespToXapp, 1}, + }) + + // Req + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) + restSubId := xappConn1.SendRESTSubsReq(t, params) + + crereq, cremsg := e2termConn1.RecvSubsReq(t) + xappConn1.ExpectRESTNotification(t, restSubId) + e2termConn1.SendSubsResp(t, crereq, cremsg) + e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) + + // Submgr should not react any other connection state changes than CONNECTED and DISCONNECTED + mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED_SETUP_FAILED") + mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTING") + mainCtrl.SetE2State(t, "RAN_NAME_1_SHUTTING_DOWN") + mainCtrl.SetE2State(t, "RAN_NAME_1_SHUT_DOWN") + + // Del + xappConn1.SendRESTSubsDelReq(t, &restSubId) + delreq, delmsg := e2termConn1.RecvSubsDelReq(t) + e2termConn1.SendSubsDelResp(t, delreq, delmsg) + + // Restore E2 connection for following test cases + mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED") + + // Wait that subs is cleaned + waitSubsCleanup(t, e2SubsId, 10) + mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) +} + +//----------------------------------------------------------------------------- +// TestRESTSubReqAndDeleteOkWithE2apUtWrapper +// +// stub stub stub +// +-------+ +---------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | | rtmgr | +// +-------+ +---------+ +---------+ +---------+ +// | | | | +// | RESTSubReq | | | +// |---------------->| | | +// | | RouteCreate | | +// | |--------------------------->| // The order of these events may vary +// | | | | +// | RESTSubResp | | | // The order of these events may vary +// |<----------------| | | +// | | RouteResponse| | +// | |<---------------------------| // The order of these events may vary +// | | | | +// | | SubReq | | +// | |------------->| | // The order of these events may vary +// | | | | +// | | SubResp | | +// | |<-------------| | +// | RESTNotif1 | | | +// |<----------------| | | +// | | | | +// | RESTSubDelReq | | | +// |---------------->| | | +// | | SubDelReq | | +// | |------------->| | +// | | | | +// | RESTSubDelResp| | | +// |<----------------| | | +// | | | | +// | | SubDelResp | | +// | |<-------------| | +// | | | | +// | | | | +// +//----------------------------------------------------------------------------- +func TestRESTSubReqAndDeleteOkWithE2apUtWrapper(t *testing.T) { restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil) deleteSubscription(t, xappConn1, e2termConn1, &restSubId) waitSubsCleanup(t, e2SubsId, 10) + mainCtrl.VerifyAllClean(t) +} + +//----------------------------------------------------------------------------- +// TestRESTSubReqAndE1apDeleteReqPackingError +// +// stub stub stub +// +-------+ +---------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | | rtmgr | +// +-------+ +---------+ +---------+ +---------+ +// | | | | +// | RESTSubReq | | | +// |---------------->| | | +// | | RouteCreate | | +// | |--------------------------->| // The order of these events may vary +// | | | | +// | RESTSubResp | | | // The order of these events may vary +// |<----------------| | | +// | | RouteResponse| | +// | |<---------------------------| // The order of these events may vary +// | | | | +// | | SubReq | | +// | |------------->| | // The order of these events may vary +// | | | | +// | | SubResp | | +// | |<-------------| | +// | RESTNotif1 | | | +// |<----------------| | | +// | | | | +// | RESTSubDelReq | | | +// |---------------->| | | +// | | | | +// | RESTSubDelResp| | | +// |<----------------| | | +// | | | | +// | | | | +// +//----------------------------------------------------------------------------- +func TestRESTSubReqAndE1apDeleteReqPackingError(t *testing.T) { + + restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil) + + e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, false) + xappConn1.SendRESTSubsDelReq(t, &restSubId) + defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, true) + + waitSubsCleanup(t, e2SubsId, 10) + mainCtrl.VerifyAllClean(t) +} + +//----------------------------------------------------------------------------- +// TestRESTSubReqAndE1apDeleteRespUnpackingError +// +// stub stub stub +// +-------+ +---------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | | rtmgr | +// +-------+ +---------+ +---------+ +---------+ +// | | | | +// | RESTSubReq | | | +// |---------------->| | | +// | | RouteCreate | | +// | |--------------------------->| // The order of these events may vary +// | | | | +// | RESTSubResp | | | // The order of these events may vary +// |<----------------| | | +// | | RouteResponse| | +// | |<---------------------------| // The order of these events may vary +// | | | | +// | | SubReq | | +// | |------------->| | // The order of these events may vary +// | | | | +// | | SubResp | | +// | |<-------------| | +// | RESTNotif1 | | | +// |<----------------| | | +// | | | | +// | RESTSubDelReq | | | +// |---------------->| | | +// | | SubDelReq | | +// | |------------->| | +// | | | | +// | RESTSubDelResp| | | +// |<----------------| | | // The order of these events may vary +// | | | | +// | | SubDelResp | | +// | |<-------------| | // 1.st NOK +// | | | | +// | | SubDelReq | | +// | |------------->| | +// | | | | +// | | SubDelResp | | +// | |<-------------| | // 2.nd NOK +// +//----------------------------------------------------------------------------- + +func TestRESTSubReqAndE1apDeleteRespUnpackingError(t *testing.T) { + + restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil) + + xappConn1.SendRESTSubsDelReq(t, &restSubId) + e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, false) + delreq, delmsg := e2termConn1.RecvSubsDelReq(t) + e2termConn1.SendSubsDelResp(t, delreq, delmsg) + + delreq, delmsg = e2termConn1.RecvSubsDelReq(t) + e2termConn1.SendSubsDelResp(t, delreq, delmsg) + + defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, true) + + waitSubsCleanup(t, e2SubsId, 10) + mainCtrl.VerifyAllClean(t) } //----------------------------------------------------------------------------- @@ -241,7 +675,6 @@ func TestSubDelReqAndRouteDeleteNok(t *testing.T) { xappConn2.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) - mainCtrl.VerifyCounterValues(t) } @@ -301,6 +734,7 @@ func TestSubMergeDelAndRouteUpdateNok(t *testing.T) { // Init counter check mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ Counter{cSubReqFromXapp, 2}, + Counter{cMergedSubscriptions, 1}, Counter{cSubReqToE2, 1}, Counter{cSubRespFromE2, 1}, Counter{cSubRespToXapp, 2}, @@ -309,6 +743,7 @@ func TestSubMergeDelAndRouteUpdateNok(t *testing.T) { Counter{cSubDelReqToE2, 1}, Counter{cSubDelRespFromE2, 1}, Counter{cSubDelRespToXapp, 2}, + Counter{cUnmergedSubscriptions, 1}, }) //Req1 @@ -835,6 +1270,7 @@ func TestSubReqRetryInSubmgr(t *testing.T) { mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ Counter{cSubReqFromXapp, 1}, Counter{cSubReqToE2, 1}, + Counter{cSubReqTimerExpiry, 1}, Counter{cSubReReqToE2, 1}, Counter{cSubRespFromE2, 1}, Counter{cSubRespToXapp, 1}, @@ -1021,12 +1457,6 @@ func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) { // | | SubFail | // | |<-------------| // | | | -// | | SubDelReq | -// | |------------->| -// | | | -// | | SubDelResp | -// | |<-------------| -// | | | // | SubFail | | // |<-------------| | // | | | @@ -1052,10 +1482,6 @@ func TestSubReqSubFailRespInSubmgr(t *testing.T) { fparams1.Set(crereq1) e2termConn1.SendSubsFail(t, fparams1, cremsg1) - // E2t: Receive SubsDelReq and send SubsDelResp (internal first) - delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t) - e2termConn1.SendSubsDelResp(t, delreq1, delmsg1) - // Xapp: Receive SubsFail e2SubsId := xappConn1.RecvSubsFail(t, cretrans) @@ -1330,8 +1756,6 @@ func TestSubReqAndSubDelOkSameAction(t *testing.T) { rparams2 := &teststube2ap.E2StubSubsReqParams{} rparams2.Init() cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil) - //crereq2, cremsg2 := e2termConn1.RecvSubsReq(t) - //e2termConn1.SendSubsResp(t, crereq2, cremsg2) e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2) resp, _ := xapp.Subscription.QuerySubscriptions() @@ -1341,11 +1765,7 @@ func TestSubReqAndSubDelOkSameAction(t *testing.T) { //Del1 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1) - //e2termConn1.RecvSubsDelReq(t) - //e2termConn1.SendSubsDelResp(t, delreq1, delmsg1) xappConn1.RecvSubsDelResp(t, deltrans1) - //Wait that subs is cleaned - //mainCtrl.wait_subs_clean(t, e2SubsId1, 10) //Del2 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2) @@ -1467,11 +1887,6 @@ func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) { // | | | SubFail1 | // | | |<-------------| // | | | | -// | | | SubDelReq | -// | | |------------->| -// | | | SubDelResp | -// | | |<-------------| -// | | | | // | | SubFail1 | | // | |<-------------| | // | | | | @@ -1502,10 +1917,6 @@ func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) { fparams1.Set(crereq1) e2termConn1.SendSubsFail(t, fparams1, cremsg1) - // E2t: internal delete - delreq, delmsg := e2termConn1.RecvSubsDelReq(t) - e2termConn1.SendSubsDelResp(t, delreq, delmsg) - //Fail1 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1) //Fail2 @@ -1963,9 +2374,6 @@ func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) { func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) { CaseBegin("TestSubReqNokAndSubDelOkWithRestartInMiddle") - // Remove possible existing subscrition - mainCtrl.removeExistingSubscriptions(t) - mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription xappConn1.SendSubsReq(t, nil, nil) e2termConn1.RecvSubsReq(t) @@ -1980,6 +2388,7 @@ func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) { mainCtrl.SimulateRestart(t) xapp.Logger.Debug("mainCtrl.SimulateRestart done") + // Submgr send delete for uncompleted subscription delreq, delmsg := e2termConn1.RecvSubsDelReq(t) e2termConn1.SendSubsDelResp(t, delreq, delmsg) @@ -2046,6 +2455,10 @@ func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) { mainCtrl.SimulateRestart(t) xapp.Logger.Debug("mainCtrl.SimulateRestart done") + // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions()) + // That needs to be completed before successful subscription query is possible + <-time.After(time.Second * 1) + // Check that subscription is restored correctly after restart resp, _ = xapp.Subscription.QuerySubscriptions() assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId)) @@ -2140,7 +2553,7 @@ func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) { e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2) // Check subscription - resp, _ := xapp.Subscription.QuerySubscriptions() //////////////////////////////// + resp, _ := xapp.Subscription.QuerySubscriptions() assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1)) assert.Equal(t, resp[0].Meid, "RAN_NAME_1") assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"}) @@ -2148,6 +2561,10 @@ func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) { mainCtrl.SimulateRestart(t) xapp.Logger.Debug("mainCtrl.SimulateRestart done") + // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions()) + // That needs to be completed before successful subscription query is possible + <-time.After(time.Second * 1) + // Check that subscription is restored correctly after restart resp, _ = xapp.Subscription.QuerySubscriptions() assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1)) @@ -2163,6 +2580,10 @@ func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) { mainCtrl.SimulateRestart(t) xapp.Logger.Debug("mainCtrl.SimulateRestart done") + // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions()) + // Submgr need be ready before successful subscription deletion is possible + <-time.After(time.Second * 1) + //Del2 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2) delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t) @@ -2216,6 +2637,11 @@ func TestPostEmptyDb(t *testing.T) { mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/emptydb") } +func TestGetRestSubscriptions(t *testing.T) { + + mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/restsubscriptions") +} + //----------------------------------------------------------------------------- // TestRESTSubReqAndRouteNok // @@ -2251,29 +2677,28 @@ func TestRESTSubReqAndRouteNok(t *testing.T) { CaseBegin("TestRESTSubReqAndRouteNok") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 1}, + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, Counter{cRouteCreateFail, 1}, - Counter{cSubRespToXapp, 1}, - Counter{cSubDelReqFromXapp, 1}, - Counter{cSubDelRespToXapp, 1}, + Counter{cRestSubFailNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, }) const subReqCount int = 1 - const parameterSet = 1 - const actionDefinitionPresent bool = true - const actionParamCount int = 1 + // 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) + xappConn1.ExpectRESTNotificationNok(t, restSubId, "failAll") waiter.WaitResult(t) e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) - xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId) + xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId) // Del xappConn1.SendRESTSubsDelReq(t, &restSubId) @@ -2282,6 +2707,7 @@ func TestRESTSubReqAndRouteNok(t *testing.T) { mainCtrl.wait_subs_clean(t, newSubsId, 10) waitSubsCleanup(t, e2SubsId, 10) mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } func TestRESTSubReqAndRouteUpdateNok(t *testing.T) { @@ -2289,15 +2715,17 @@ func TestRESTSubReqAndRouteUpdateNok(t *testing.T) { //Init counter check mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 2}, + Counter{cRestSubReqFromXapp, 2}, + Counter{cRestSubRespToXapp, 2}, Counter{cSubReqToE2, 1}, Counter{cSubRespFromE2, 1}, - Counter{cSubRespToXapp, 2}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubFailNotifToXapp, 1}, Counter{cRouteCreateUpdateFail, 1}, - Counter{cSubDelReqFromXapp, 1}, + Counter{cRestSubDelReqFromXapp, 2}, Counter{cSubDelReqToE2, 1}, Counter{cSubDelRespFromE2, 1}, - Counter{cSubDelRespToXapp, 1}, + Counter{cRestSubDelRespToXapp, 2}, }) var params *teststube2ap.RESTSubsReqParams = nil @@ -2310,24 +2738,25 @@ 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) - xappConn2.ExpectRESTNotification(t, restSubId2) + xapp.Logger.Debug("Send REST subscriber request for second subscriber : %v", restSubId2) + xappConn2.ExpectRESTNotificationNok(t, restSubId2, "allFail") waiter.WaitResult(t) - // e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) - TOD: missing delete xappConn2.WaitRESTNotification(t, restSubId2) queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"}) deleteSubscription(t, xappConn1, e2termConn1, &restSubId) + xappConn2.SendRESTSubsDelReq(t, &restSubId2) mainCtrl.wait_subs_clean(t, newSubsId, 10) //Wait that subs is cleaned waitSubsCleanup(t, e2SubsId, 10) mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) { @@ -2335,15 +2764,16 @@ func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) { // Init counter check mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 1}, + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, Counter{cSubReqToE2, 1}, Counter{cSubRespFromE2, 1}, - Counter{cSubRespToXapp, 1}, - Counter{cSubDelReqFromXapp, 1}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, Counter{cRouteDeleteFail, 1}, Counter{cSubDelReqToE2, 1}, Counter{cSubDelRespFromE2, 1}, - Counter{cSubDelRespToXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, }) var params *teststube2ap.RESTSubsReqParams = nil @@ -2360,23 +2790,26 @@ func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) { waiter.WaitResult(t) waitSubsCleanup(t, e2SubsId, 10) - mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) { CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 2}, + Counter{cRestSubReqFromXapp, 2}, + Counter{cMergedSubscriptions, 1}, + Counter{cRestSubRespToXapp, 2}, Counter{cSubReqToE2, 1}, Counter{cSubRespFromE2, 1}, - Counter{cSubRespToXapp, 2}, - Counter{cSubDelReqFromXapp, 2}, + Counter{cRestSubNotifToXapp, 2}, + Counter{cRestSubDelReqFromXapp, 2}, Counter{cRouteDeleteUpdateFail, 1}, Counter{cSubDelReqToE2, 1}, Counter{cSubDelRespFromE2, 1}, - Counter{cSubDelRespToXapp, 2}, + Counter{cRestSubDelRespToXapp, 2}, + Counter{cUnmergedSubscriptions, 1}, }) var params *teststube2ap.RESTSubsReqParams = nil @@ -2400,8 +2833,8 @@ func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) { deleteXapp2Subscription(t, &restSubId2) waitSubsCleanup(t, e2SubsId2, 10) - mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } //----------------------------------------------------------------------------- @@ -2423,19 +2856,13 @@ func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) { // | RESTSubReq2 | | // | (retrans) | | // |---------------->| | -// | | | -// | | SubReq2 | -// | |------------->| -// | RESTSubResp2 | | +// | RESTSubResp(201)| | // |<----------------| | +// | | | // | | SubResp1 | // | |<-------------| // | RESTNotif1 | | // |<----------------| | -// | | SubResp1 | -// | |<-------------| -// | RESTNotif2 | | -// |<----------------| | // | | | // | [SUBS DELETE] | // | | | @@ -2446,77 +2873,617 @@ func TestRESTSubReqRetransmission(t *testing.T) { CaseBegin("TestRESTSubReqRetransmission") 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}, + Counter{cRestSubReqFromXapp, 2}, + Counter{cRestSubRespToXapp, 2}, + Counter{cSubReqToE2, 1}, + Counter{cSubRespFromE2, 1}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cSubDelReqToE2, 1}, + Counter{cSubDelRespFromE2, 1}, + Counter{cRestSubDelRespToXapp, 1}, }) - // Retry/duplicate will get the same way as the first request. Submgr cannot detect duplicate RESTRequests + // Retry/duplicate will get the same way as the first request. // Contianed duplicate messages from same xapp will not be merged. 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 // 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) - restSubId1 := xappConn1.SendRESTSubsReq(t, params) - restSubId2 := xappConn2.SendRESTSubsReq(t, params) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) + restSubId := xappConn1.SendRESTSubsReq(t, params) - waiter.WaitResult(t) + xappConn1.SendRESTSubsReq(t, params) + <-time.After(time.Second * 1) - xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2}) + xappConn1.WaitListedRestNotifications(t, []string{restSubId}) // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus - // the order is not significant he6re. + // the order is not significant here. crereq, cremsg := e2termConn1.RecvSubsReq(t) e2termConn1.SendSubsResp(t, crereq, cremsg) - crereq, cremsg = e2termConn1.RecvSubsReq(t) - e2termConn1.SendSubsResp(t, crereq, cremsg) - 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) + e2SubsId := <-xappConn1.ListedRESTNotifications + + xapp.Logger.Debug("TEST: XAPP notification received e2SubsId=%v", e2SubsId) // Del1 - xappConn1.SendRESTSubsDelReq(t, &restSubId1) + xappConn1.SendRESTSubsDelReq(t, &restSubId) delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t) e2termConn1.SendSubsDelResp(t, delreq1, delmsg1) - // Del2 - xappConn2.SendRESTSubsDelReq(t, &restSubId2) - delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t) - e2termConn1.SendSubsDelResp(t, delreq2, delmsg2) + mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsId.E2SubsId}, 10) - mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10) + mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) +} - waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10) +//----------------------------------------------------------------------------- +// stub stub stub +// +-------+ +---------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | | rtmgr | +// +-------+ +---------+ +---------+ +---------+ +// | | | | +// | RESTSubReq | | | +// |---------------->| | | +// | RESTSubResp | | | +// |<----------------| | | +// | | RouteCreate | | +// | |--------------------------->| +// | | RouteResponse| | +// | |<---------------------------| // The order of these events may vary +// | | SubReq | | +// | |------------->| | // The order of these events may vary +// | | SubResp | | +// | |<-------------| | +// | RESTNotif1 | | | +// |<----------------| | | +// | RESTSubReq | | | +// | [RETRANS1] | | | +// |---------------->| | | +// | RESTNotif1 | | | +// |<----------------| | | +// | RESTSubReq | | | +// | [RETRANS2] | | | +// |---------------->| | | +// | RESTNotif1 | | | +// |<----------------| | | +// | RESTSubDelReq | | | +// |---------------->| | | +// | | SubDelReq | | +// | |------------->| | +// | RESTSubDelResp| | | +// |<----------------| | | +// | | SubDelResp | | +// | |<-------------| | +// | | | | +// +//----------------------------------------------------------------------------- + +func TestRESTSubReqRetransmissionV2(t *testing.T) { + CaseBegin("TestRESTSubReqRetransmissionV2") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 3}, + Counter{cDuplicateE2SubReq, 2}, + Counter{cRestSubRespToXapp, 3}, + Counter{cSubReqToE2, 1}, + Counter{cSubRespFromE2, 1}, + Counter{cRestSubNotifToXapp, 3}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cSubDelReqToE2, 1}, + Counter{cSubDelRespFromE2, 1}, + Counter{cRestSubDelRespToXapp, 1}, + }) + + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) + + restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) + + queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"}) + + mainCtrl.WaitOngoingRequestMapEmpty() + + //1.st resend + restSubId_resend := xappConn1.SendRESTSubsReq(t, params) + + assert.Equal(t, restSubId_resend, restSubId) + + mainCtrl.WaitOngoingRequestMapEmpty() + + //2.nd resend + restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params) + + assert.Equal(t, restSubId_resend2, restSubId) + + mainCtrl.WaitOngoingRequestMapEmpty() + + deleteSubscription(t, xappConn1, e2termConn1, &restSubId) + + waitSubsCleanup(t, e2SubsId, 10) + mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) +} + +//----------------------------------------------------------------------------- +// stub stub stub +// +-------+ +---------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | | rtmgr | +// +-------+ +---------+ +---------+ +---------+ +// | | | | +// | RESTSubReq | | | +// |---------------->| | | +// | RESTSubResp | | | +// |<----------------| | | +// | | RouteCreate | | +// | |--------------------------->| +// | | RouteResponse| | +// | |<---------------------------| // The order of these events may vary +// | | SubReq | | +// | |------------->| | // The order of these events may vary +// | | SubResp | | +// | |<-------------| | +// | RESTNotif1 | | | +// |<----------------| | | +// | RESTSubReq | | | +// | [RETRANS, with RESTsubsId] | | +// |---------------->| | | +// | RESTNotif1 | | | +// |<----------------| | | +// | RESTSubReq | | | +// | [RETRANS, without RESTsubsId] | | +// |---------------->| | | +// | RESTNotif1 | | | +// |<----------------| | | +// | RESTSubDelReq | | | +// |---------------->| | | +// | | SubDelReq | | +// | |------------->| | +// | RESTSubDelResp| | | +// |<----------------| | | +// | | SubDelResp | | +// | |<-------------| | +// | | | | +// +//----------------------------------------------------------------------------- +func TestRESTSubReqRetransmissionV3(t *testing.T) { + CaseBegin("TestRESTSubReqRetransmissionV3") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 3}, + Counter{cDuplicateE2SubReq, 2}, + Counter{cRestSubRespToXapp, 3}, + Counter{cSubReqToE2, 1}, + Counter{cSubRespFromE2, 1}, + Counter{cRestSubNotifToXapp, 3}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cSubDelReqToE2, 1}, + Counter{cSubDelRespFromE2, 1}, + Counter{cRestSubDelRespToXapp, 1}, + }) + + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) + + restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) + + queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"}) + + mainCtrl.WaitOngoingRequestMapEmpty() + + //1.st resend with subscription ID + params.SetSubscriptionID(&restSubId) + restSubId_resend := xappConn1.SendRESTSubsReq(t, params) + + assert.Equal(t, restSubId_resend, restSubId) + + mainCtrl.WaitOngoingRequestMapEmpty() + + //2.nd resend without subscription ID (faking app restart) + params = xappConn1.GetRESTSubsReqReportParams(subReqCount) + restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params) + + assert.Equal(t, restSubId_resend2, restSubId) + + mainCtrl.WaitOngoingRequestMapEmpty() + + deleteSubscription(t, xappConn1, e2termConn1, &restSubId) + + waitSubsCleanup(t, e2SubsId, 10) + mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) +} + +//----------------------------------------------------------------------------- +// stub stub stub +// +-------+ +---------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | | rtmgr | +// +-------+ +---------+ +---------+ +---------+ +// | | | | +// | RESTSubReq | | | +// |---------------->| | | +// | RESTSubResp | | | +// |<----------------| | | +// | | RouteCreate | | +// | |--------------------------->| +// | | RouteResponse| | +// | |<---------------------------| +// | | SubReq | | +// | |------------->| | +// | | SubResp | | +// | |<-------------| | +// | RESTNotif1 | | | +// |<----------------| | | +// | RESTSubReq | | | +// | [with RestSUbsId + one additional e2 subDetail] +// |---------------->| | | +// | RESTNotif1 | | | +// | [for initial e2 subDetail] | | +// |<----------------| | | +// | | RouteCreate | | +// | |--------------------------->| +// | | RouteResponse| | +// | |<---------------------------| +// | | SubReq | | +// | |------------->| | +// | | SubResp | | +// | |<-------------| | +// | RESTNotif1 | | | +// |<----------------| | | +// | RESTSubReq | | | +// | [with RESTsubsId initial request] | +// |---------------->| | | +// | RESTNotif1 | | | +// |<----------------| | | +// | RESTSubDelReq | | | +// |---------------->| | | +// | RESTSubDelResp| | | +// |<----------------| | | +// | | SubDelReq | | +// | |------------->| | +// | | SubDelResp | | +// | |<-------------| | +// | | SubDelReq | | +// | |------------->| | +// | | SubDelResp | | +// | |<-------------| | +// | | | | +// +//----------------------------------------------------------------------------- + +func TestRESTSubReqRetransmissionV4(t *testing.T) { + CaseBegin("TestRESTSubReqRetransmissionV4") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 3}, + Counter{cDuplicateE2SubReq, 2}, + Counter{cRestSubRespToXapp, 3}, + Counter{cSubReqToE2, 2}, + Counter{cSubRespFromE2, 2}, + Counter{cRestSubNotifToXapp, 4}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cSubDelReqToE2, 2}, + Counter{cSubDelRespFromE2, 2}, + Counter{cRestSubDelRespToXapp, 1}, + }) + + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) + + restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) + + mainCtrl.WaitOngoingRequestMapEmpty() + + // Send modified requst, this time with e2 subscriptions. + params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1) + params2.SetSubscriptionID(&restSubId) + + xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler) + xappConn1.ExpectAnyNotification(t) + // Resend the original request with an additional e2 subscription (detail), this time with restsubsid + restSubId_resend := xappConn1.SendRESTSubsReq(t, params2) + e2SubsId1 := xappConn1.WaitAnyRESTNotification(t) + assert.Equal(t, e2SubsId, e2SubsId1) + + crereq2, cremsg2 := e2termConn1.RecvSubsReq(t) + + xappConn1.DecrementRequestCount() + xappConn1.ExpectRESTNotification(t, restSubId_resend) + e2termConn1.SendSubsResp(t, crereq2, cremsg2) + e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend) + assert.NotEqual(t, e2SubsId2, 0) + mainCtrl.WaitOngoingRequestMapEmpty() + + xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler) + params = xappConn1.GetRESTSubsReqReportParams(subReqCount) + params.SetSubscriptionID(&restSubId) + xappConn1.ExpectAnyNotification(t) + // Resend the original request again with only one e2 subscription (detail), this time with restsubsid + restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params) + assert.Equal(t, restSubId_resend, restSubId_resend2) + + e2SubsId1 = xappConn1.WaitAnyRESTNotification(t) + assert.Equal(t, e2SubsId, e2SubsId1) + + mainCtrl.WaitOngoingRequestMapEmpty() + + // Delete both e2 subscriptions + xappConn1.SendRESTSubsDelReq(t, &restSubId) + e2SubsIds := []uint32{e2SubsId, e2SubsId2} + sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1) + + waitSubsCleanup(t, e2SubsId, 10) + mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) +} + +//----------------------------------------------------------------------------- +// stub stub stub +// +-------+ +---------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | | rtmgr | +// +-------+ +---------+ +---------+ +---------+ +// | | | | +// | RESTSubReq | | | +// |---------------->| | | +// | RESTSubResp | | | +// |<----------------| | | +// | | RouteCreate | | +// | |--------------------------->| +// | | RouteResponse| | +// | |<---------------------------| +// | | SubReq | | +// | |------------->| | +// | | SubResp | | +// | |<-------------| | +// | RESTNotif1 | | | +// |<----------------| | | +// | RESTSubReq | | | +// | [with RestSUbsId + one additional e2 subDetail] +// |---------------->| | | +// | RESTNotif1 | | | +// | [for initial e2 subDetail] | | +// |<----------------| | | +// | | RouteCreate | | +// | |--------------------------->| +// | | RouteResponse| | +// | |<---------------------------| +// | | SubReq | | +// | |------------->| | +// | | SubResp | | +// | |<-------------| | +// | RESTNotif1 | | | +// |<----------------| | | +// | RESTSubReq | | | +// | [without RESTsubsId initial request] | +// |---------------->| | | +// | RESTNotif1 | | | +// |<----------------| | | +// | RESTSubDelReq | | | +// |---------------->| | | +// | RESTSubDelResp| | | +// |<----------------| | | +// | | SubDelReq | | +// | |------------->| | +// | | SubDelResp | | +// | |<-------------| | +// | | SubDelReq | | +// | |------------->| | +// | | SubDelResp | | +// | |<-------------| | +// | | | | +// +//----------------------------------------------------------------------------- + +func TestRESTSubReqRetransmissionV5(t *testing.T) { + CaseBegin("TestRESTSubReqRetransmissionV5") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 3}, + Counter{cDuplicateE2SubReq, 2}, + Counter{cRestSubRespToXapp, 3}, + Counter{cSubReqToE2, 2}, + Counter{cSubRespFromE2, 2}, + Counter{cRestSubNotifToXapp, 4}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cSubDelReqToE2, 2}, + Counter{cSubDelRespFromE2, 2}, + Counter{cRestSubDelRespToXapp, 1}, + }) + + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) + + restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) + + mainCtrl.WaitOngoingRequestMapEmpty() + + // Send modified request, this time with e2 subscriptions. + params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1) + params2.SetSubscriptionID(&restSubId) + + xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler) + xappConn1.ExpectAnyNotification(t) + // Resend the original request with an additional e2 subscription (detail), this time with restsubsid + restSubId_resend := xappConn1.SendRESTSubsReq(t, params2) + + e2SubsId1 := xappConn1.WaitAnyRESTNotification(t) + assert.Equal(t, e2SubsId, e2SubsId1) + // The first E2 subscription returns immediately, manually decrement expected request count for the remaining request handling + xappConn1.DecrementRequestCount() + + crereq2, cremsg2 := e2termConn1.RecvSubsReq(t) + + xappConn1.ExpectRESTNotification(t, restSubId_resend) + e2termConn1.SendSubsResp(t, crereq2, cremsg2) + e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend) + assert.NotEqual(t, e2SubsId2, 0) + + mainCtrl.WaitOngoingRequestMapEmpty() + + xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler) + params = xappConn1.GetRESTSubsReqReportParams(subReqCount) + xappConn1.ExpectAnyNotification(t) + // Resend the original request again with only one e2 subscription (detail), WITHOUT restsubsid + // md5sum shall find the original request + restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params) + assert.Equal(t, restSubId_resend, restSubId_resend2) + + e2SubsId1 = xappConn1.WaitAnyRESTNotification(t) + assert.Equal(t, e2SubsId, e2SubsId1) + + mainCtrl.WaitOngoingRequestMapEmpty() + + // Delete both e2 subscriptions + xappConn1.SendRESTSubsDelReq(t, &restSubId) + e2SubsIds := []uint32{e2SubsId, e2SubsId2} + sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1) + + waitSubsCleanup(t, e2SubsId, 10) + mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) +} + +//----------------------------------------------------------------------------- +// stub stub stub +// +-------+ +---------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | | rtmgr | +// +-------+ +---------+ +---------+ +---------+ +// | | | | +// | RESTSubReq | | | +// |---------------->| | | +// | RESTSubResp | | | +// |<----------------| | | +// | | RouteCreate | | +// | |--------------------------->| +// | | RouteResponse| | +// | |<---------------------------| +// | | SubReq | | +// | |------------->| | +// | | SubResp | | +// | |<-------------| | +// | RESTNotif1 | | | +// |<----------------| | | +// | RESTSubReq | | | +// | [with RestSUbsId + one additional e2 subDetail] +// |---------------->| | | +// | RESTNotif1 | | | +// | [for initial e2 subDetail] | | +// |<----------------| | | +// | | RouteCreate | | +// | |--------------------------->| +// | | RouteResponse| | +// | |<---------------------------| +// | | SubReq | | +// | |------------->| | +// | | SubResp | | +// | |<-------------| | +// | RESTNotif1 | | | +// |<----------------| | | +// | RESTSubDelReq | | | +// |---------------->| | | +// | RESTSubDelResp| | | +// |<----------------| | | +// | | SubDelReq | | +// | |------------->| | +// | | SubDelResp | | +// | |<-------------| | +// | | SubDelReq | | +// | |------------->| | +// | | SubDelResp | | +// | |<-------------| | +// | RESTSubReq | | | +// | [with RESTsubsId initial request] | +// |---------------->| | | +// | RESTSubResp | | | +// |<----------------| | | +// | | RouteCreate | | +// | |--------------------------->| +// | | RouteResponse| | +// | |<---------------------------| +// | | SubReq | | +// | |------------->| | +// | | SubResp | | +// | |<-------------| | +// | RESTNotif1 | | | +// |<----------------| | | +// | | | | +// +//----------------------------------------------------------------------------- +func TestRESTSubReqRetransmissionV6(t *testing.T) { + CaseBegin("TestRESTSubReqRetransmissionV6") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 3}, + Counter{cDuplicateE2SubReq, 1}, + Counter{cRestSubRespToXapp, 3}, + Counter{cSubReqToE2, 3}, + Counter{cSubRespFromE2, 3}, + Counter{cRestSubNotifToXapp, 4}, + Counter{cRestSubDelReqFromXapp, 2}, + Counter{cSubDelReqToE2, 3}, + Counter{cSubDelRespFromE2, 3}, + Counter{cRestSubDelRespToXapp, 2}, + }) + + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) + + restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) + + mainCtrl.WaitOngoingRequestMapEmpty() + + // Send modified requst, this time with e2 subscriptions. + params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1) + params2.SetSubscriptionID(&restSubId) + + xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler) + xappConn1.ExpectAnyNotification(t) + // Resend the original request with an additional e2 subscription (detail), this time with restsubsid + restSubId_resend := xappConn1.SendRESTSubsReq(t, params2) + + e2SubsId1 := xappConn1.WaitAnyRESTNotification(t) + assert.Equal(t, e2SubsId, e2SubsId1) + + crereq2, cremsg2 := e2termConn1.RecvSubsReq(t) + + xappConn1.ExpectRESTNotification(t, restSubId_resend) + e2termConn1.SendSubsResp(t, crereq2, cremsg2) + e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend) + assert.NotEqual(t, e2SubsId2, 0) + + mainCtrl.WaitOngoingRequestMapEmpty() + + // Delete both e2 subscriptions + xappConn1.SendRESTSubsDelReq(t, &restSubId) + e2SubsIds := []uint32{e2SubsId, e2SubsId2} + sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1) + + waitSubsCleanup(t, e2SubsId, 10) + + // Resend the original request, we shall find it's previous md5sum/restsubs + // but the restsubscription has been already removed. This shall trigger a + // fresh create. + restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params) + + mainCtrl.WaitOngoingRequestMapEmpty() + + deleteSubscription(t, xappConn1, e2termConn1, &restSubId) + + waitSubsCleanup(t, e2SubsId, 10) mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } func TestRESTSubDelReqRetransmission(t *testing.T) { CaseBegin("TestRESTSubDelReqRetransmission") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 1}, + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, Counter{cSubReqToE2, 1}, Counter{cSubRespFromE2, 1}, - Counter{cSubRespToXapp, 1}, - Counter{cSubDelReqFromXapp, 2}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 2}, Counter{cSubDelReqToE2, 1}, Counter{cSubDelRespFromE2, 1}, - Counter{cSubDelRespToXapp, 1}, + Counter{cRestSubDelRespToXapp, 2}, }) var params *teststube2ap.RESTSubsReqParams = nil @@ -2537,8 +3504,8 @@ func TestRESTSubDelReqRetransmission(t *testing.T) { e2termConn1.SendSubsDelResp(t, delreq, delmsg) waitSubsCleanup(t, e2SubsId, 10) - mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } //----------------------------------------------------------------------------- @@ -2574,23 +3541,22 @@ func TestRESTSubReqDelReq(t *testing.T) { CaseBegin("TestRESTSubReqDelReq") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 1}, + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, Counter{cSubReqToE2, 1}, Counter{cSubRespFromE2, 1}, - Counter{cSubRespToXapp, 1}, - Counter{cSubDelReqFromXapp, 2}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 2}, + Counter{cRestSubDelFailToXapp, 1}, Counter{cSubDelReqToE2, 1}, Counter{cSubDelRespFromE2, 1}, - Counter{cSubDelRespToXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, }) 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 @@ -2611,7 +3577,7 @@ func TestRESTSubReqDelReq(t *testing.T) { // Wait that subs is cleaned waitSubsCleanup(t, e2SubsId, 10) mainCtrl.VerifyCounterValues(t) - + mainCtrl.VerifyAllClean(t) } func TestRESTSubDelReqCollision(t *testing.T) { @@ -2622,25 +3588,26 @@ func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) { CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 2}, + Counter{cRestSubReqFromXapp, 2}, + Counter{cRestSubRespToXapp, 2}, Counter{cSubReqToE2, 2}, Counter{cSubRespFromE2, 2}, - Counter{cSubRespToXapp, 2}, - Counter{cSubDelReqFromXapp, 2}, + Counter{cRestSubNotifToXapp, 2}, + Counter{cRestSubDelReqFromXapp, 2}, Counter{cSubDelReqToE2, 2}, Counter{cSubDelRespFromE2, 2}, - Counter{cSubDelRespToXapp, 2}, + Counter{cRestSubDelRespToXapp, 2}, }) //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) + xapp.Logger.Debug("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) + xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2) crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) crereq2, cremsg2 := e2termConn1.RecvSubsReq(t) @@ -2654,9 +3621,9 @@ func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) { e2termConn1.SendSubsResp(t, crereq2, cremsg2) e2SubsIdA := <-xappConn1.ListedRESTNotifications - xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA) + xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA) e2SubsIdB := <-xappConn1.ListedRESTNotifications - xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB) + xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB) //Del1 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1) @@ -2668,31 +3635,32 @@ func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) { waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10) mainCtrl.VerifyCounterValues(t) - + mainCtrl.VerifyAllClean(t) } func TestRESTSameSubsDiffRan(t *testing.T) { CaseBegin("TestRESTSameSubsDiffRan") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 2}, + Counter{cRestSubReqFromXapp, 2}, + Counter{cRestSubRespToXapp, 2}, Counter{cSubReqToE2, 2}, Counter{cSubRespFromE2, 2}, - Counter{cSubRespToXapp, 2}, - Counter{cSubDelReqFromXapp, 2}, + Counter{cRestSubNotifToXapp, 2}, + Counter{cRestSubDelReqFromXapp, 2}, Counter{cSubDelReqToE2, 2}, Counter{cSubDelRespFromE2, 2}, - Counter{cSubDelRespToXapp, 2}, + Counter{cRestSubDelRespToXapp, 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) + xapp.Logger.Debug("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) + xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2) //Del1 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1) @@ -2704,7 +3672,7 @@ func TestRESTSameSubsDiffRan(t *testing.T) { waitSubsCleanup(t, e2SubsId2, 10) mainCtrl.VerifyCounterValues(t) - + mainCtrl.VerifyAllClean(t) } func TestRESTSubReqRetryInSubmgr(t *testing.T) { @@ -2712,25 +3680,27 @@ func TestRESTSubReqRetryInSubmgr(t *testing.T) { // Init counter check mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 1}, + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, Counter{cSubReqToE2, 1}, + Counter{cSubReqTimerExpiry, 1}, Counter{cSubReReqToE2, 1}, Counter{cSubRespFromE2, 1}, - Counter{cSubRespToXapp, 1}, - Counter{cSubDelReqFromXapp, 1}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, Counter{cSubDelReqToE2, 1}, Counter{cSubDelRespFromE2, 1}, - Counter{cSubDelRespToXapp, 1}, + Counter{cRestSubDelRespToXapp, 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) + xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId) // Catch the first message and ignore it crereq, cremsg := e2termConn1.RecvSubsReq(t) - xapp.Logger.Info("Ignore REST subscriber request for subscriber : %v", restSubId) + xapp.Logger.Debug("Ignore REST subscriber request for subscriber : %v", restSubId) // The second request is being handled normally crereq, cremsg = e2termConn1.RecvSubsReq(t) @@ -2747,7 +3717,7 @@ func TestRESTSubReqRetryInSubmgr(t *testing.T) { waitSubsCleanup(t, e2SubsId, 10) mainCtrl.VerifyCounterValues(t) - + mainCtrl.VerifyAllClean(t) } //----------------------------------------------------------------------------- @@ -2788,39 +3758,45 @@ func TestRESTSubReqRetryInSubmgr(t *testing.T) { // | | | // //----------------------------------------------------------------------------- + func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) { CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start") // Init counter check mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 1}, + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, Counter{cSubReqToE2, 1}, Counter{cSubReReqToE2, 1}, Counter{cSubReqTimerExpiry, 2}, + Counter{cRestSubFailNotifToXapp, 1}, Counter{cSubDelReqToE2, 1}, Counter{cSubDelRespFromE2, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 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) + xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId) e2termConn1.RecvSubsReq(t) - xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId) + xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId) e2termConn1.RecvSubsReq(t) - xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId) + xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId) delreq, delmsg := e2termConn1.RecvSubsDelReq(t) - xappConn1.ExpectRESTNotification(t, restSubId) + xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") e2termConn1.SendSubsDelResp(t, delreq, delmsg) - // e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) - TODO: Should we delete this? xappConn1.WaitRESTNotification(t, restSubId) + xappConn1.SendRESTSubsDelReq(t, &restSubId) + // Wait that subs is cleaned waitSubsCleanup(t, delreq.RequestId.InstanceId, 10) - mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } func TestREST2eTermNotRespondingToSubReq(t *testing.T) { @@ -2828,37 +3804,43 @@ func TestREST2eTermNotRespondingToSubReq(t *testing.T) { // Init counter check mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 1}, + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, Counter{cSubReqToE2, 1}, Counter{cSubReReqToE2, 1}, Counter{cSubReqTimerExpiry, 2}, + Counter{cSubDelReReqToE2, 1}, + Counter{cRestSubFailNotifToXapp, 1}, Counter{cSubDelReqToE2, 1}, Counter{cSubDelReqTimerExpiry, 2}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 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) + xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId) e2termConn1.RecvSubsReq(t) - xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId) + xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId) e2termConn1.RecvSubsReq(t) - xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId) + xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId) e2termConn1.RecvSubsDelReq(t) - xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId) + xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId) - xappConn1.ExpectRESTNotification(t, restSubId) + xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") e2termConn1.RecvSubsDelReq(t) - xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId) + xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId) e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) - waitSubsCleanup(t, e2SubsId, 10) + xappConn1.SendRESTSubsDelReq(t, &restSubId) + waitSubsCleanup(t, e2SubsId, 10) mainCtrl.VerifyCounterValues(t) - + mainCtrl.VerifyAllClean(t) } //----------------------------------------------------------------------------- @@ -2904,37 +3886,43 @@ func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) { // Init counter check mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 1}, + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, Counter{cSubReqToE2, 1}, Counter{cSubReReqToE2, 1}, Counter{cSubReqTimerExpiry, 2}, + Counter{cRestSubFailNotifToXapp, 1}, Counter{cSubDelReqToE2, 1}, Counter{cSubDelReReqToE2, 1}, Counter{cSubDelReqTimerExpiry, 2}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 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) + xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId) e2termConn1.RecvSubsReq(t) - xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId) + xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId) e2termConn1.RecvSubsReq(t) - xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId) + xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId) e2termConn1.RecvSubsDelReq(t) - xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId) + xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId) - xappConn1.ExpectRESTNotification(t, restSubId) + xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") e2termConn1.RecvSubsDelReq(t) - xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId) + xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId) e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) - waitSubsCleanup(t, e2SubsId, 10) + xappConn1.SendRESTSubsDelReq(t, &restSubId) + waitSubsCleanup(t, e2SubsId, 10) mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } //----------------------------------------------------------------------------- @@ -2956,12 +3944,6 @@ func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) { // | | SubFail | // | |<-------------| // | | | -// | | SubDelReq | -// | |------------->| -// | | | -// | | SubDelResp | -// | |<-------------| -// | | | // | RESTNotif | | // | unsuccess | | // |<----------------| | @@ -2974,31 +3956,32 @@ func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) { CaseBegin("TestRESTSubReqSubFailRespInSubmgr") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 1}, + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, Counter{cSubReqToE2, 1}, Counter{cSubFailFromE2, 1}, - Counter{cSubRespToXapp, 1}, - Counter{cSubDelReqFromXapp, 1}, + Counter{cRestSubFailNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, }) const subReqCount int = 1 - const parameterSet = 1 - const actionDefinitionPresent bool = true - const actionParamCount int = 1 + const e2Timeout int64 = 2 + const e2RetryCount int64 = 1 + const routingNeeded bool = true - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) + params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded) restSubId := xappConn1.SendRESTSubsReq(t, params) crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) fparams1 := &teststube2ap.E2StubSubsFailParams{} fparams1.Set(crereq1) + xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") e2termConn1.SendSubsFail(t, fparams1, cremsg1) - delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t) - xappConn1.ExpectRESTNotification(t, restSubId) - e2termConn1.SendSubsDelResp(t, delreq1, delmsg1) e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) - xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId) + xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId) // REST subscription sill there to be deleted xappConn1.SendRESTSubsDelReq(t, &restSubId) @@ -3007,7 +3990,7 @@ func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) { waitSubsCleanup(t, e2SubsId, 10) mainCtrl.VerifyCounterValues(t) - + mainCtrl.VerifyAllClean(t) } //----------------------------------------------------------------------------- @@ -3041,15 +4024,17 @@ func TestRESTSubDelReqRetryInSubmgr(t *testing.T) { CaseBegin("TestRESTSubDelReqRetryInSubmgr") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 1}, + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, Counter{cSubReqToE2, 1}, Counter{cSubRespFromE2, 1}, - Counter{cSubRespToXapp, 1}, - Counter{cSubDelReqFromXapp, 1}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, Counter{cSubDelReqToE2, 1}, + Counter{cSubDelReqTimerExpiry, 1}, Counter{cSubDelReReqToE2, 1}, Counter{cSubDelRespFromE2, 1}, - Counter{cSubDelRespToXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, }) // Req var params *teststube2ap.RESTSubsReqParams = nil @@ -3069,6 +4054,7 @@ func TestRESTSubDelReqRetryInSubmgr(t *testing.T) { waitSubsCleanup(t, e2SubsId, 10) mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } //----------------------------------------------------------------------------- @@ -3100,15 +4086,17 @@ func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) { CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 1}, + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, Counter{cSubReqToE2, 1}, Counter{cSubRespFromE2, 1}, - Counter{cSubRespToXapp, 1}, - Counter{cSubDelReqFromXapp, 1}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, Counter{cSubDelReqToE2, 1}, + Counter{cSubDelReqTimerExpiry, 1}, Counter{cSubDelReReqToE2, 1}, Counter{cSubDelRespFromE2, 1}, - Counter{cSubDelRespToXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, }) // Req @@ -3129,6 +4117,7 @@ func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) { waitSubsCleanup(t, e2SubsId, 10) mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } //----------------------------------------------------------------------------- @@ -3159,14 +4148,15 @@ func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) { CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 1}, + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, Counter{cSubReqToE2, 1}, Counter{cSubRespFromE2, 1}, - Counter{cSubRespToXapp, 1}, - Counter{cSubDelReqFromXapp, 1}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, Counter{cSubDelReqToE2, 1}, Counter{cSubDelFailFromE2, 1}, - Counter{cSubDelRespToXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, }) // Req @@ -3184,6 +4174,7 @@ func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) { waitSubsCleanup(t, e2SubsId, 10) mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } //----------------------------------------------------------------------------- @@ -3240,16 +4231,17 @@ func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) { CaseBegin("TestRESTSubReqAndSubDelOkSameAction") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 2}, + Counter{cRestSubReqFromXapp, 2}, + Counter{cRestSubRespToXapp, 2}, Counter{cSubReqToE2, 1}, Counter{cSubRespFromE2, 1}, - Counter{cSubRespToXapp, 2}, + Counter{cRestSubNotifToXapp, 2}, Counter{cMergedSubscriptions, 1}, Counter{cUnmergedSubscriptions, 1}, - Counter{cSubDelReqFromXapp, 2}, + Counter{cRestSubDelReqFromXapp, 2}, Counter{cSubDelReqToE2, 1}, Counter{cSubDelRespFromE2, 1}, - Counter{cSubDelRespToXapp, 2}, + Counter{cRestSubDelRespToXapp, 2}, }) // Req1 @@ -3260,17 +4252,17 @@ 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) - xappConn2.WaitRESTNotificationForAnySubscriptionId(t) + xappConn2.ExpectAnyNotification(t) waiter := rtmgrHttp.AllocNextSleep(10, true) restSubId2 := xappConn2.SendRESTSubsReq(t, params) waiter.WaitResult(t) - xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) - e2SubsId2 := <-xappConn2.RESTNotification - xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2) + xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2) + e2SubsId2 := xappConn2.WaitAnyRESTNotification(t) + xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2) queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"}) @@ -3282,8 +4274,8 @@ func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) { //Wait that subs is cleaned waitSubsCleanup(t, e2SubsId2, 10) - mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } //----------------------------------------------------------------------------- @@ -3337,21 +4329,22 @@ func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) { CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 2}, + Counter{cRestSubReqFromXapp, 2}, + Counter{cRestSubRespToXapp, 2}, Counter{cSubReqToE2, 2}, Counter{cSubRespFromE2, 2}, - Counter{cSubRespToXapp, 2}, - Counter{cSubDelReqFromXapp, 2}, + Counter{cRestSubNotifToXapp, 2}, + Counter{cRestSubDelReqFromXapp, 2}, Counter{cSubDelReqToE2, 2}, Counter{cSubDelRespFromE2, 2}, - Counter{cSubDelRespToXapp, 2}, + Counter{cRestSubDelRespToXapp, 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) @@ -3375,8 +4368,8 @@ func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) { e2termConn1.SendSubsDelResp(t, delreq2, delmsg2) waitSubsCleanup(t, e2SubsId2, 10) - mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } //----------------------------------------------------------------------------- @@ -3399,7 +4392,7 @@ func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) { // | RESTSubReq2 | | // |------------------------------>| | // | | | | -// | RESTSubDelResp2 | | +// | RESTSubResp2 | | // |<------------------------------| | // | | | SubReq1 | // | | |------------->| @@ -3434,28 +4427,29 @@ func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) { CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 2}, + Counter{cRestSubReqFromXapp, 2}, + Counter{cMergedSubscriptions, 1}, + Counter{cRestSubRespToXapp, 2}, Counter{cSubReqToE2, 1}, - Counter{cSubRespToXapp, 2}, - Counter{cSubDelReqFromXapp, 2}, + Counter{cSubReqTimerExpiry, 2}, + Counter{cSubReReqToE2, 1}, + Counter{cRestSubFailNotifToXapp, 2}, + Counter{cUnmergedSubscriptions, 1}, + Counter{cRestSubDelReqFromXapp, 2}, Counter{cSubDelReqToE2, 1}, Counter{cSubDelRespFromE2, 1}, - Counter{cSubDelRespToXapp, 2}, + Counter{cRestSubDelRespToXapp, 2}, }) - 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) @@ -3469,9 +4463,9 @@ func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) { e2termConn1.SendSubsDelResp(t, delreq1, delmsg1) e2SubsIdA := <-xappConn1.ListedRESTNotifications - xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA) + xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA) e2SubsIdB := <-xappConn1.ListedRESTNotifications - xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB) + xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB) // Del1 xappConn1.SendRESTSubsDelReq(t, &restSubId1) @@ -3483,8 +4477,8 @@ func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) { //Wait that subs is cleaned waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10) - mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } //----------------------------------------------------------------------------- @@ -3518,12 +4512,8 @@ func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) { // | RESTNotif2 | | // | | unsuccess | | // |<------------------------------| | -// | | | SubDelReq | -// | | |------------->| -// | | | SubDelResp | -// | | |<-------------| // | | | | -// | | RESTSubDelReq1 | | +// | | RESTSubDelReq1 | | There is no need for xApp to send delete for failed subscriptions but some xApp might do so. // | |---------------->| | // | | | | // | | RESTSubDelResp1 | | @@ -3540,29 +4530,27 @@ func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) { CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 2}, + Counter{cRestSubReqFromXapp, 2}, + Counter{cMergedSubscriptions, 1}, + Counter{cRestSubRespToXapp, 2}, Counter{cSubReqToE2, 1}, Counter{cSubFailFromE2, 1}, - Counter{cSubRespToXapp, 2}, - Counter{cSubDelReqFromXapp, 2}, - Counter{cSubDelReqToE2, 1}, - Counter{cSubDelRespFromE2, 1}, - Counter{cSubDelRespToXapp, 2}, + Counter{cRestSubFailNotifToXapp, 2}, + Counter{cUnmergedSubscriptions, 1}, + Counter{cRestSubDelReqFromXapp, 2}, + Counter{cRestSubDelRespToXapp, 2}, }) 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) @@ -3572,15 +4560,11 @@ func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) { fparams1.Set(crereq1) e2termConn1.SendSubsFail(t, fparams1, cremsg1) - // E2t: internal delete - delreq, delmsg := e2termConn1.RecvSubsDelReq(t) xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2}) - e2termConn1.SendSubsDelResp(t, delreq, delmsg) - e2SubsIdA := <-xappConn1.ListedRESTNotifications - xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA) + xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA) e2SubsIdB := <-xappConn1.ListedRESTNotifications - xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB) + xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB) // Del1 xappConn1.SendRESTSubsDelReq(t, &restSubId1) @@ -3591,8 +4575,8 @@ func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) { //Wait that subs is cleaned waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10) waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10) - mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) { @@ -3600,30 +4584,26 @@ func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) { // Init counter check mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 1}, + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, Counter{cSubReqToE2, 1}, Counter{cSubRespFromE2, 1}, - Counter{cSubRespToXapp, 1}, - Counter{cSubDelReqFromXapp, 1}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, Counter{cSubDelReqToE2, 1}, Counter{cSubDelRespFromE2, 1}, - Counter{cSubDelRespToXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, }) - 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) + xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId) crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) xappConn1.ExpectRESTNotification(t, restSubId) e2termConn1.SendSubsResp(t, crereq1, cremsg1) e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) - xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId) + xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId) xappConn1.SendRESTSubsDelReq(t, &restSubId) delreq, delmsg := e2termConn1.RecvSubsDelReq(t) @@ -3632,6 +4612,7 @@ func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) { // Wait that subs is cleaned waitSubsCleanup(t, e2SubsId, 10) mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } //----------------------------------------------------------------------------- @@ -3687,30 +4668,33 @@ func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) { CaseBegin("TestRESTSubReqPolicyAndSubDelOk") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 2}, + Counter{cRestSubReqFromXapp, 2}, + Counter{cRestSubRespToXapp, 2}, Counter{cSubReqToE2, 2}, Counter{cSubRespFromE2, 2}, - Counter{cSubRespToXapp, 2}, - Counter{cSubDelReqFromXapp, 1}, + Counter{cRestSubNotifToXapp, 2}, + Counter{cRestSubDelReqFromXapp, 1}, Counter{cSubDelReqToE2, 1}, Counter{cSubDelRespFromE2, 1}, - Counter{cSubDelRespToXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, }) const subReqCount int = 1 - const parameterSet = 1 - const actionDefinitionPresent bool = true - const policyParamCount int = 1 + const e2Timeout int64 = 1 + const e2RetryCount int64 = 0 + const routingNeeded bool = true // Req - params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount) + params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) + params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded) 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.SubsReqParams.SubscriptionDetails[0].InstanceID = &instanceId + // GetRESTSubsReqPolicyParams sets some counters on tc side. + + params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount) + params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded) + params.SetSubscriptionID(&restSubId) params.SetTimeToWait("w200ms") restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params) @@ -3723,6 +4707,89 @@ func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) { // Wait that subs is cleaned waitSubsCleanup(t, e2SubsId, 10) mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) +} + +//----------------------------------------------------------------------------- +// TestRESTSubReqPolicyChangeNOk +// +// stub stub +// +-------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | +// +-------+ +---------+ +---------+ +// | | | +// | RESTSubReq | | +// |---------------->| | +// | | | +// | RESTSubResp | | +// |<----------------| | +// | | SubReq | +// | |------------->| +// | | | +// | | SubResp | +// | |<-------------| +// | | | +// | RESTNotif | | +// |<----------------| | +// | | | +// | RESTSubReq | | +// |---------------->| | +// | | | +// | RESTSubUpdateFail(400 Bad request) +// | | | +// | RESTSubDelReq | | +// |---------------->| | +// | | | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelResp | +// | |<-------------| +// | | | +// | RESTSubDelResp | | +// |<----------------| | +// +//----------------------------------------------------------------------------- +func TestRESTSubReqPolicyChangeNOk(t *testing.T) { + CaseBegin("TestRESTSubReqPolicyChangeNOk") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 2}, + Counter{cRestSubRespToXapp, 1}, + Counter{cSubReqToE2, 1}, + Counter{cSubRespFromE2, 1}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubFailToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cSubDelReqToE2, 1}, + Counter{cSubDelRespFromE2, 1}, + Counter{cRestSubDelRespToXapp, 1}, + }) + + // Req + params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) + restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) + + // Policy change + params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount) + + restSubIdUpd := strings.ToUpper(restSubId) // This makes RESTSubReq to fail + params.SetSubscriptionID(&restSubIdUpd) + params.SetTimeToWait("w200ms") + + restSubId2 := xappConn1.SendRESTSubsReq(t, params) + assert.Equal(t, restSubId2, "") + + // Del + xappConn1.SendRESTSubsDelReq(t, &restSubId) + + delreq, delmsg := e2termConn1.RecvSubsDelReq(t) + e2termConn1.SendSubsDelResp(t, delreq, delmsg) + + // Wait that subs is cleaned + waitSubsCleanup(t, e2SubsId, 10) + mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } //----------------------------------------------------------------------------- @@ -3771,28 +4838,26 @@ func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) { // Init counter check mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 2}, + Counter{cRestSubReqFromXapp, 2}, + Counter{cRestSubRespToXapp, 2}, Counter{cSubReqToE2, 2}, Counter{cSubRespFromE2, 2}, - Counter{cSubRespToXapp, 2}, - Counter{cSubDelReqFromXapp, 2}, + Counter{cRestSubNotifToXapp, 2}, + Counter{cRestSubDelReqFromXapp, 2}, Counter{cSubDelReqToE2, 2}, Counter{cSubDelRespFromE2, 2}, - Counter{cSubDelRespToXapp, 2}, + Counter{cRestSubDelRespToXapp, 2}, }) 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 @@ -3803,13 +4868,13 @@ func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) { xappConn1.ExpectRESTNotification(t, restSubId1) e2termConn1.SendSubsResp(t, crereq1, cremsg1) e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1) - xapp.Logger.Info("TEST: REST notification received e2SubsId1=%v", e2SubsId1) + xapp.Logger.Debug("TEST: REST notification received e2SubsId1=%v", e2SubsId1) // Resp2 xappConn2.ExpectRESTNotification(t, restSubId2) e2termConn2.SendSubsResp(t, crereq2, cremsg2) e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) - xapp.Logger.Info("TEST: REST notification received e2SubsId2=%v", e2SubsId2) + xapp.Logger.Debug("TEST: REST notification received e2SubsId2=%v", e2SubsId2) // Delete1 xappConn1.SendRESTSubsDelReq(t, &restSubId1) @@ -3828,6 +4893,7 @@ func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) { waitSubsCleanup(t, e2SubsId2, 10) mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } //----------------------------------------------------------------------------- @@ -3855,7 +4921,7 @@ func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) { func TestRESTSubReqAsn1EncodeFail(t *testing.T) { CaseBegin("TestRESTSubReqAsn1EncodeFail") - xapp.Logger.Info("Xapp-frame, v0.8.1 sufficient REST API validation") + xapp.Logger.Debug("Xapp-frame, v0.8.1 sufficient REST API validation") } @@ -3899,22 +4965,20 @@ func TestRESTSubReqInsertAndSubDelOk(t *testing.T) { CaseBegin("TestRESTInsertSubReqAndSubDelOk") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 1}, + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, Counter{cSubReqToE2, 1}, Counter{cSubRespFromE2, 1}, - Counter{cSubRespToXapp, 1}, - Counter{cSubDelReqFromXapp, 1}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, Counter{cSubDelReqToE2, 1}, Counter{cSubDelRespFromE2, 1}, - Counter{cSubDelRespToXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, }) 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 @@ -3929,6 +4993,7 @@ func TestRESTSubReqInsertAndSubDelOk(t *testing.T) { // Wait that subs is cleaned waitSubsCleanup(t, e2SubsId, 10) mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } //----------------------------------------------------------------------------- @@ -3942,6 +5007,8 @@ func TestRESTSubReqInsertAndSubDelOk(t *testing.T) { // | RESTSubReq | | // |------------->| | // | | | +// | RESTSubResp | | +// |<-------------| | // | | SubReq | // | |------------->| // | | | @@ -3957,33 +5024,39 @@ func TestRESTSubReqInsertAndSubDelOk(t *testing.T) { // | | SubDelResp | // | |<-------------| // | | | +// | RESTNotif | | +// | unsuccess | | +// |<-------------| | +// | | | +// | RESTSubDelReq| | +// |------------->| | +// | | | +// |RESTSubDelResp| | +// |<-------------| | // //----------------------------------------------------------------------------- func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) { CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 1}, + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, Counter{cSubReqToE2, 1}, Counter{cSubDelReqFromXapp, 1}, Counter{cSubDelReqToE2, 1}, Counter{cSubDelRespFromE2, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, }) 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 restSubId := xappConn1.SendRESTSubsReq(t, params) - xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId) + xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId) e2termConn1.RecvSubsReq(t) @@ -3992,16 +5065,19 @@ func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) { mainCtrl.SimulateRestart(t) xapp.Logger.Debug("mainCtrl.SimulateRestart done") - //Del + // Deleletion of uncompleted subscription delreq, delmsg := e2termConn1.RecvSubsDelReq(t) e2termConn1.SendSubsDelResp(t, delreq, delmsg) + //Del + xappConn1.SendRESTSubsDelReq(t, &restSubId) + xappConn1.TestMsgChanEmpty(t) - xappConn2.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } //----------------------------------------------------------------------------- @@ -4042,37 +5118,36 @@ func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) { // |<----------------| | // //----------------------------------------------------------------------------- + func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) { CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 1}, + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, Counter{cSubReqToE2, 1}, Counter{cSubRespFromE2, 1}, - Counter{cSubRespToXapp, 1}, - Counter{cSubDelReqFromXapp, 1}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, Counter{cSubDelReqToE2, 1}, - Counter{cSubDelRespToXapp, 1}, + Counter{cSubDelRespFromE2, 1}, + Counter{cRestSubDelRespToXapp, 1}, }) - // Remove possible existing subscription - mainCtrl.removeExistingSubscriptions(t) - - var params *teststube2ap.RESTSubsReqParams = nil - // Create subscription + var params *teststube2ap.RESTSubsReqParams = nil restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) - xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId) + xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId) // Check subscription queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"}) - // When SDL support for the REST Interface is added - // the submgr restart statement below should be removed - // from the comment. + mainCtrl.SimulateRestart(t) + xapp.Logger.Debug("mainCtrl.SimulateRestart done") - // mainCtrl.SimulateRestart(t) - // xapp.Logger.Debug("mainCtrl.SimulateRestart done") + // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions()) + // That needs to be completed before successful subscription query is possible + <-time.After(time.Second * 1) // Check subscription queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"}) @@ -4084,6 +5159,7 @@ func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) { waitSubsCleanup(t, e2SubsId, 10) mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } //----------------------------------------------------------------------------- @@ -4144,57 +5220,55 @@ func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) { CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 2}, + Counter{cRestSubReqFromXapp, 2}, + Counter{cRestSubRespToXapp, 2}, Counter{cSubReqToE2, 1}, Counter{cSubRespFromE2, 1}, - Counter{cSubRespToXapp, 2}, + Counter{cRestSubNotifToXapp, 2}, Counter{cMergedSubscriptions, 1}, Counter{cUnmergedSubscriptions, 1}, - Counter{cSubDelReqFromXapp, 2}, + Counter{cRestSubDelReqFromXapp, 2}, Counter{cSubDelReqToE2, 1}, Counter{cSubDelRespFromE2, 1}, - Counter{cSubDelRespToXapp, 2}, + Counter{cRestSubDelRespToXapp, 2}, }) - // Remove possible existing subscription - mainCtrl.removeExistingSubscriptions(t) - - var params *teststube2ap.RESTSubsReqParams = nil - // Create subscription 1 + var params *teststube2ap.RESTSubsReqParams = nil restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) - xapp.Logger.Info("Send REST subscriber request for subscriber 1 : %v", restSubId1) + xapp.Logger.Debug("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) + xappConn2.ExpectAnyNotification(t) restSubId2 := xappConn2.SendRESTSubsReq(t, params) - xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) - e2SubsId2 := <-xappConn2.RESTNotification - xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2) + xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2) + e2SubsId2 := xappConn2.WaitAnyRESTNotification(t) + xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2) queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"}) - // When SDL support for the REST Interface is added - // the submgr restart statement below should be removed - // from the comment. + mainCtrl.SimulateRestart(t) + xapp.Logger.Debug("mainCtrl.SimulateRestart done 1") - // mainCtrl.SimulateRestart(t) - // xapp.Logger.Debug("mainCtrl.SimulateRestart done") + // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions()) + // That needs to be completed before successful subscription delete is possible + <-time.After(time.Second * 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) + mainCtrl.WaitRESTSubscriptionDelete(restSubId1) + // Above wait does not work correctly anymore as this delay makes this test case work + + mainCtrl.SimulateRestart(t) + xapp.Logger.Debug("mainCtrl.SimulateRestart done 2") - // When SDL support for the REST Interface is added - // the submgr restart statement below should be removed - // from the comment. + // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions()) + // That needs to be completed before successful subscription query is possible + <-time.After(time.Second * 1) - // mainCtrl.SimulateRestart(t) - // xapp.Logger.Debug("mainCtrl.SimulateRestart done") queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"}) // Delete subscription 2 @@ -4204,6 +5278,7 @@ func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) { waitSubsCleanup(t, e2SubsId2, 10) mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } //----------------------------------------------------------------------------- @@ -4240,31 +5315,41 @@ func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) { // | RESTSubDelReq | | // |---------------->| | // | | | +// | RESTSubDelResp| | +// |<----------------| | // | | SubDelReq | // | |------------->| // | | | // | | SubDelResp | // | |<-------------| // | | | -// | RESTSubDelResp| | -// |<----------------| | // //----------------------------------------------------------------------------- + func TestRESTReportSubReqAndSubDelOk(t *testing.T) { CaseBegin("TestRESTReportSubReqAndSubDelOk") - subReqCount := 1 - parameterSet := 1 // E2SM-gNB-X2 - actionDefinitionPresent := true - actionParamCount := 1 + const subReqCount int = 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.Debug("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex) + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, + Counter{cSubReqToE2, uint64(subReqCount)}, + Counter{cSubRespFromE2, uint64(subReqCount)}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, + Counter{cSubDelReqToE2, uint64(subReqCount)}, + Counter{cSubDelRespFromE2, uint64(subReqCount)}, + }) // Req - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) var e2SubsId []uint32 @@ -4274,7 +5359,7 @@ func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, parameterSet int e2termConn1.SendSubsResp(t, crereq, cremsg) instanceId := xappConn1.WaitRESTNotification(t, restSubId) - xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId) + xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId) e2SubsId = append(e2SubsId, instanceId) resp, _ := xapp.Subscription.QuerySubscriptions() assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId)) @@ -4299,33 +5384,41 @@ func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, parameterSet int xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) + mainCtrl.VerifyAllClean(t) + mainCtrl.VerifyCounterValues(t) } /* -func TestRESTPolicySubReqAndSubDelOk(t *testing.T) { +func TestRESTPolicySubReqAndSubDelOk(t *testing.T) { //Was in comments already. Next case is not run! 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.Debug("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex) + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, + Counter{cSubReqToE2, uint64(subReqCount)}, + Counter{cSubRespFromE2, uint64(subReqCount)}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, + Counter{cSubDelReqToE2, uint64(subReqCount)}, + Counter{cSubDelRespFromE2, uint64(subReqCount)}, + }) // Req - params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount) + params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) - //params := xappConn1.GetRESTSubsReqPolicyParams1(subReqCount, actionDefinitionPresent, policyParamCount) - //restSubId := xappConn1.SendRESTPolicySubsReq(t, params) var e2SubsId []uint32 for i := 0; i < subReqCount; i++ { @@ -4333,7 +5426,7 @@ func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, actionDefinition xappConn1.ExpectRESTNotification(t, restSubId) e2termConn1.SendSubsResp(t, crereq, cremsg) instanceId := xappConn1.WaitRESTNotification(t, restSubId) - xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId) + xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId) e2SubsId = append(e2SubsId, instanceId) } @@ -4352,25 +5445,28 @@ func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, actionDefinition xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) + mainCtrl.VerifyAllClean(t) + mainCtrl.VerifyCounterValues(t) } func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) { - subReqCount := 2 - mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 1}, + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, Counter{cSubReqToE2, 2}, Counter{cSubRespFromE2, 2}, - Counter{cSubRespToXapp, 2}, - Counter{cSubDelReqFromXapp, 1}, + Counter{cRestSubNotifToXapp, 2}, + Counter{cRestSubDelReqFromXapp, 1}, Counter{cSubDelReqToE2, 2}, Counter{cSubDelRespFromE2, 2}, - Counter{cSubDelRespToXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, }) + const subReqCount int = 2 + // Req - params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount) + params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId) @@ -4385,24 +5481,25 @@ func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) { mainCtrl.wait_registry_empty(t, 10) mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) { - subReqCount := 19 - mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 1}, + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, Counter{cSubReqToE2, 19}, Counter{cSubRespFromE2, 19}, - Counter{cSubRespToXapp, 19}, - Counter{cSubDelReqFromXapp, 1}, + Counter{cRestSubNotifToXapp, 19}, + Counter{cRestSubDelReqFromXapp, 1}, Counter{cSubDelReqToE2, 19}, Counter{cSubDelRespFromE2, 19}, - Counter{cSubDelRespToXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, }) + const subReqCount int = 19 // Req - params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount) + params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId) @@ -4416,27 +5513,27 @@ func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) { mainCtrl.wait_registry_empty(t, 10) mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } + func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) { subReqCount := 2 - parameterSet := 1 - actionDefinitionPresent := true - actionParamCount := 1 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 1}, + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, Counter{cSubReqToE2, uint64(subReqCount)}, Counter{cSubRespFromE2, uint64(subReqCount)}, - Counter{cSubRespToXapp, uint64(subReqCount)}, - Counter{cSubDelReqFromXapp, 1}, + Counter{cRestSubNotifToXapp, uint64(subReqCount)}, + Counter{cRestSubDelReqFromXapp, 1}, Counter{cSubDelReqToE2, uint64(subReqCount)}, Counter{cSubDelRespFromE2, uint64(subReqCount)}, - Counter{cSubDelRespToXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, }) // Req - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId) @@ -4451,28 +5548,27 @@ func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) { mainCtrl.wait_registry_empty(t, 10) mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) { subReqCount := 2 - parameterSet := 1 - actionDefinitionPresent := false - actionParamCount := 0 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 1}, + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, Counter{cSubReqToE2, uint64(subReqCount)}, Counter{cSubRespFromE2, uint64(subReqCount)}, - Counter{cSubRespToXapp, uint64(subReqCount)}, - Counter{cSubDelReqFromXapp, 1}, + Counter{cRestSubNotifToXapp, uint64(subReqCount)}, + Counter{cRestSubDelReqFromXapp, 1}, Counter{cSubDelReqToE2, uint64(subReqCount)}, Counter{cSubDelRespFromE2, uint64(subReqCount)}, - Counter{cSubDelRespToXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, }) // Req - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId) @@ -4487,28 +5583,27 @@ func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) { mainCtrl.wait_registry_empty(t, 10) mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) { subReqCount := 19 - parameterSet := 1 - actionDefinitionPresent := false - actionParamCount := 0 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 1}, + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, Counter{cSubReqToE2, uint64(subReqCount)}, Counter{cSubRespFromE2, uint64(subReqCount)}, - Counter{cSubRespToXapp, uint64(subReqCount)}, - Counter{cSubDelReqFromXapp, 1}, + Counter{cRestSubNotifToXapp, uint64(subReqCount)}, + Counter{cRestSubDelReqFromXapp, 1}, Counter{cSubDelReqToE2, uint64(subReqCount)}, Counter{cSubDelRespFromE2, uint64(subReqCount)}, - Counter{cSubDelRespToXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, }) // Req - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId) @@ -4523,20 +5618,22 @@ func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) { mainCtrl.wait_registry_empty(t, 10) mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(t) } func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) { CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 2}, + Counter{cRestSubReqFromXapp, 2}, + Counter{cRestSubRespToXapp, 2}, Counter{cSubReqToE2, 2}, Counter{cSubRespFromE2, 2}, - Counter{cSubRespToXapp, 2}, - Counter{cSubDelReqFromXapp, 2}, + Counter{cRestSubNotifToXapp, 2}, + Counter{cRestSubDelReqFromXapp, 2}, Counter{cSubDelReqToE2, 2}, Counter{cSubDelRespFromE2, 2}, - Counter{cSubDelRespToXapp, 2}, + Counter{cRestSubDelRespToXapp, 2}, }) // Req1 @@ -4544,18 +5641,18 @@ func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) { //Subs Create restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) - xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1) + xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1) 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") - eventTriggerDefinition := "1234" + eventTriggerDefinition := []int64{1234, 1} params.SetSubEventTriggerDefinition(eventTriggerDefinition) restSubId2 := xappConn2.SendRESTSubsReq(t, params) - xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) + xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2) crereq, cremsg := e2termConn1.RecvSubsReq(t) xappConn2.ExpectRESTNotification(t, restSubId2) e2termConn1.SendSubsResp(t, crereq, cremsg) @@ -4568,21 +5665,22 @@ func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) { waitSubsCleanup(t, e2SubsId2, 10) mainCtrl.VerifyCounterValues(t) - + mainCtrl.VerifyAllClean(t) } func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) { CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 2}, + Counter{cRestSubReqFromXapp, 2}, + Counter{cRestSubRespToXapp, 2}, Counter{cSubReqToE2, 2}, Counter{cSubRespFromE2, 2}, - Counter{cSubRespToXapp, 2}, - Counter{cSubDelReqFromXapp, 2}, + Counter{cRestSubNotifToXapp, 2}, + Counter{cRestSubDelReqFromXapp, 2}, Counter{cSubDelReqToE2, 2}, Counter{cSubDelRespFromE2, 2}, - Counter{cSubDelRespToXapp, 2}, + Counter{cRestSubDelRespToXapp, 2}, }) // Req1 @@ -4590,23 +5688,23 @@ func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) { //Subs Create restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) - xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1) + xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1) 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") actionId := int64(1) actionType := "report" - actionDefinition := "56781" + actionDefinition := []int64{5678, 1} 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) + xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2) crereq, cremsg := e2termConn1.RecvSubsReq(t) xappConn2.ExpectRESTNotification(t, restSubId2) e2termConn1.SendSubsResp(t, crereq, cremsg) @@ -4619,21 +5717,22 @@ func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) { waitSubsCleanup(t, e2SubsId2, 10) mainCtrl.VerifyCounterValues(t) - + mainCtrl.VerifyAllClean(t) } func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) { CaseBegin("TestRESTSubReqReportSameActionDiffActionID") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 2}, + Counter{cRestSubReqFromXapp, 2}, + Counter{cRestSubRespToXapp, 2}, Counter{cSubReqToE2, 2}, Counter{cSubRespFromE2, 2}, - Counter{cSubRespToXapp, 2}, - Counter{cSubDelReqFromXapp, 2}, + Counter{cRestSubNotifToXapp, 2}, + Counter{cRestSubDelReqFromXapp, 2}, Counter{cSubDelReqToE2, 2}, Counter{cSubDelRespFromE2, 2}, - Counter{cSubDelRespToXapp, 2}, + Counter{cRestSubDelRespToXapp, 2}, }) // Req1 @@ -4641,17 +5740,17 @@ func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) { //Subs Create restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) - xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1) + xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1) 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") params.SetSubActionIDs(int64(2)) restSubId2 := xappConn2.SendRESTSubsReq(t, params) - xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) + xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2) crereq, cremsg := e2termConn1.RecvSubsReq(t) xappConn2.ExpectRESTNotification(t, restSubId2) e2termConn1.SendSubsResp(t, crereq, cremsg) @@ -4664,38 +5763,45 @@ func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) { waitSubsCleanup(t, e2SubsId2, 10) mainCtrl.VerifyCounterValues(t) - + mainCtrl.VerifyAllClean(t) } func TestRESTSubReqDiffActionType(t *testing.T) { CaseBegin("TestRESTSubReqDiffActionType") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 2}, + Counter{cRestSubReqFromXapp, 2}, + Counter{cRestSubRespToXapp, 2}, Counter{cSubReqToE2, 2}, Counter{cSubRespFromE2, 2}, - Counter{cSubRespToXapp, 2}, - Counter{cSubDelReqFromXapp, 2}, + Counter{cRestSubNotifToXapp, 2}, + Counter{cRestSubDelReqFromXapp, 2}, Counter{cSubDelReqToE2, 2}, Counter{cSubDelRespFromE2, 2}, - Counter{cSubDelRespToXapp, 2}, + Counter{cRestSubDelRespToXapp, 2}, }) + const e2Timeout int64 = 2 + const e2RetryCount int64 = 2 + const routingNeeded bool = true + // Req1 - params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount) + params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) + params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded) //Subs Create restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) - xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1) + xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1) queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"}) // Req2 - params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params = xappConn2.GetRESTSubsReqReportParams(subReqCount) + params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded) params.SetMeid("RAN_NAME_1") restSubId2 := xappConn2.SendRESTSubsReq(t, params) - xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) + xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2) crereq, cremsg := e2termConn1.RecvSubsReq(t) xappConn2.ExpectRESTNotification(t, restSubId2) e2termConn1.SendSubsResp(t, crereq, cremsg) @@ -4708,38 +5814,45 @@ func TestRESTSubReqDiffActionType(t *testing.T) { waitSubsCleanup(t, e2SubsId2, 10) mainCtrl.VerifyCounterValues(t) - + mainCtrl.VerifyAllClean(t) } func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) { CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 2}, + Counter{cRestSubReqFromXapp, 2}, + Counter{cRestSubRespToXapp, 2}, Counter{cSubReqToE2, 2}, Counter{cSubRespFromE2, 2}, - Counter{cSubRespToXapp, 2}, - Counter{cSubDelReqFromXapp, 2}, + Counter{cRestSubNotifToXapp, 2}, + Counter{cRestSubDelReqFromXapp, 2}, Counter{cSubDelReqToE2, 2}, Counter{cSubDelRespFromE2, 2}, - Counter{cSubDelRespToXapp, 2}, + Counter{cRestSubDelRespToXapp, 2}, }) + const e2Timeout int64 = 2 + const e2RetryCount int64 = 2 + const routingNeeded bool = true + // Req1 - params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount) + params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) + params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded) //Subs Create restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) - xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1) + xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1) queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"}) // Req2 - params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount) + params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount) + params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded) params.SetMeid("RAN_NAME_1") restSubId2 := xappConn2.SendRESTSubsReq(t, params) - xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) + xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2) crereq, cremsg := e2termConn1.RecvSubsReq(t) xappConn2.ExpectRESTNotification(t, restSubId2) e2termConn1.SendSubsResp(t, crereq, cremsg) @@ -4752,21 +5865,22 @@ func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) { waitSubsCleanup(t, e2SubsId2, 10) mainCtrl.VerifyCounterValues(t) - + mainCtrl.VerifyAllClean(t) } func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) { CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 2}, + Counter{cRestSubReqFromXapp, 2}, + Counter{cRestSubRespToXapp, 2}, Counter{cSubReqToE2, 2}, Counter{cSubRespFromE2, 2}, - Counter{cSubRespToXapp, 2}, - Counter{cSubDelReqFromXapp, 2}, + Counter{cRestSubNotifToXapp, 2}, + Counter{cRestSubDelReqFromXapp, 2}, Counter{cSubDelReqToE2, 2}, Counter{cSubDelRespFromE2, 2}, - Counter{cSubDelRespToXapp, 2}, + Counter{cRestSubDelRespToXapp, 2}, }) // Req1 @@ -4774,18 +5888,18 @@ func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) { //Subs Create restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) - xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1) + xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1) 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") - actionDefinition := "5678" + actionDefinition := []int64{5678, 1} params.SetSubActionDefinition(actionDefinition) restSubId2 := xappConn2.SendRESTSubsReq(t, params) - xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) + xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2) crereq, cremsg := e2termConn1.RecvSubsReq(t) xappConn2.ExpectRESTNotification(t, restSubId2) e2termConn1.SendSubsResp(t, crereq, cremsg) @@ -4798,21 +5912,22 @@ func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) { waitSubsCleanup(t, e2SubsId2, 10) mainCtrl.VerifyCounterValues(t) - + mainCtrl.VerifyAllClean(t) } func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) { CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 2}, + Counter{cRestSubReqFromXapp, 2}, + Counter{cRestSubRespToXapp, 2}, Counter{cSubReqToE2, 2}, Counter{cSubRespFromE2, 2}, - Counter{cSubRespToXapp, 2}, - Counter{cSubDelReqFromXapp, 2}, + Counter{cRestSubNotifToXapp, 2}, + Counter{cRestSubDelReqFromXapp, 2}, Counter{cSubDelReqToE2, 2}, Counter{cSubDelRespFromE2, 2}, - Counter{cSubDelRespToXapp, 2}, + Counter{cRestSubDelRespToXapp, 2}, }) // Req1 @@ -4820,18 +5935,18 @@ func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) { //Subs Create restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) - xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1) + xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1) 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") - actionDefinition := "56782" + actionDefinition := []int64{56782} params.SetSubActionDefinition(actionDefinition) restSubId2 := xappConn2.SendRESTSubsReq(t, params) - xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) + xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2) crereq, cremsg := e2termConn1.RecvSubsReq(t) xappConn2.ExpectRESTNotification(t, restSubId2) e2termConn1.SendSubsResp(t, crereq, cremsg) @@ -4844,21 +5959,22 @@ func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) { waitSubsCleanup(t, e2SubsId2, 10) mainCtrl.VerifyCounterValues(t) - + mainCtrl.VerifyAllClean(t) } func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) { CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ - Counter{cSubReqFromXapp, 2}, + Counter{cRestSubReqFromXapp, 2}, + Counter{cRestSubRespToXapp, 2}, Counter{cSubReqToE2, 2}, Counter{cSubRespFromE2, 2}, - Counter{cSubRespToXapp, 2}, - Counter{cSubDelReqFromXapp, 2}, + Counter{cRestSubNotifToXapp, 2}, + Counter{cRestSubDelReqFromXapp, 2}, Counter{cSubDelReqToE2, 2}, Counter{cSubDelRespFromE2, 2}, - Counter{cSubDelRespToXapp, 2}, + Counter{cRestSubDelRespToXapp, 2}, }) // Req1 @@ -4866,16 +5982,16 @@ func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) { //Subs Create restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) - xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1) + xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1) 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") params.SetTimeToWait("w200ms") restSubId2 := xappConn2.SendRESTSubsReq(t, params) - xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) + xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2) crereq, cremsg := e2termConn1.RecvSubsReq(t) xappConn2.ExpectRESTNotification(t, restSubId2) e2termConn1.SendSubsResp(t, crereq, cremsg) @@ -4888,7 +6004,7 @@ func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) { waitSubsCleanup(t, e2SubsId2, 10) mainCtrl.VerifyCounterValues(t) - + mainCtrl.VerifyAllClean(t) } //----------------------------------------------------------------------------- @@ -4909,7 +6025,7 @@ func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) { // | |------------->| // | | | // | | SubResp | ASN.1 decode fails -// | |<-------------| +// | |<-------------| Decode failed. More data needed. This will result timer expiry and resending // | | | // | | SubReq | // | |------------->| @@ -4918,22 +6034,32 @@ func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) { // | |<-------------| // | RESTNotif (fail)| | // |<----------------| | -// | | SubDelReq | -// | |------------->| // | | | -// | | SubDelResp | -// | |<-------------| +// | [SUBS DELETE] | +// | | | // //----------------------------------------------------------------------------- + func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) { - xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseDecodeFail") - subReqCount := 1 - parameterSet := 1 // E2SM-gNB-X2 - actionDefinitionPresent := true - actionParamCount := 1 + xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseDecodeFail") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, + Counter{cSubReqToE2, 1}, + Counter{cSubReqTimerExpiry, 1}, + Counter{cSubReReqToE2, 1}, + Counter{cSubRespFromE2, 1}, + Counter{cSubFailFromE2, 1}, + Counter{cRestSubFailNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, + }) + + const subReqCount int = 1 // Req - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) crereq, cremsg := e2termConn1.RecvSubsReq(t) @@ -4942,7 +6068,7 @@ func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) { _, cremsg = e2termConn1.RecvSubsReq(t) - xappConn1.ExpectRESTNotification(t, restSubId) + xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") // Subscription already created in E2 Node. fparams := &teststube2ap.E2StubSubsFailParams{} @@ -4950,11 +6076,10 @@ func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) { 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) + xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId) + + xappConn1.SendRESTSubsDelReq(t, &restSubId) // Wait that subs is cleaned mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10) @@ -4962,6 +6087,8 @@ func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) { xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) + mainCtrl.VerifyAllClean(t) + mainCtrl.VerifyCounterValues(t) } //----------------------------------------------------------------------------- @@ -4982,13 +6109,13 @@ func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) { // | |------------->| // | | | // | | SubResp | Unknown instanceId -// | |<-------------| +// | |<-------------| No valid subscription found with subIds [0] // | | | // | | SubReq | // | |------------->| // | | | // | | SubFail | Duplicated action -// | |<-------------| +// | |<-------------| No valid subscription found with subIds [0] // | RESTNotif (fail)| | // |<----------------| | // | | SubDelReq | @@ -4996,31 +6123,48 @@ func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) { // | | | // | | SubDelResp | // | |<-------------| +// | | | +// | [SUBS DELETE] | +// | | | // //----------------------------------------------------------------------------- + func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) { - xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId") - subReqCount := 1 - parameterSet := 1 // E2SM-gNB-X2 - actionDefinitionPresent := true - actionParamCount := 1 + xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, + Counter{cSubReqToE2, 1}, + Counter{cSubReqTimerExpiry, 2}, + Counter{cSubReReqToE2, 1}, + Counter{cSubRespFromE2, 1}, + Counter{cSubFailFromE2, 1}, + Counter{cRestSubFailNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, + Counter{cSubDelReqToE2, 1}, + Counter{cSubDelRespFromE2, 1}, + }) + + const subReqCount int = 1 // Req - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + 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 + // Unknown instanceId 0 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) + xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") - // Subscription already created in E2 Node. + // Subscription already created in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0 fparams := &teststube2ap.E2StubSubsFailParams{} fparams.Set(crereq) fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action @@ -5030,7 +6174,9 @@ func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) { e2termConn1.SendSubsDelResp(t, delreq, delmsg) instanceId := xappConn1.WaitRESTNotification(t, restSubId) - xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId) + xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId) + + xappConn1.SendRESTSubsDelReq(t, &restSubId) // Wait that subs is cleaned mainCtrl.wait_subs_clean(t, orgInstanceId, 10) @@ -5038,6 +6184,8 @@ func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) { xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) + mainCtrl.VerifyAllClean(t) + mainCtrl.VerifyCounterValues(t) } //----------------------------------------------------------------------------- @@ -5058,37 +6206,55 @@ func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) { // | |------------->| // | | | // | | SubResp | No transaction for the response -// | |<-------------| +// | |<-------------| Ongoing transaction not found. This will result timer expiry and resending // | | | // | | SubReq | // | |------------->| // | | | // | | SubFail | Duplicated action -// | |<-------------| +// | |<-------------|Ongoing transaction not found. This will result timer expiry and sending delete // | RESTNotif (fail)| | // |<----------------| | // | | SubDelReq | // | |------------->| // | | | // | | SubDelResp | -// | |<-------------| +// | |<-------------| Ongoing transaction not found. This will result timer expiry and resending // | | | // | | SubDelReq | // | |------------->| // | | | // | | SubDelResp | -// | |<-------------| +// | |<-------------| Ongoing transaction not found. +// | | | +// | [SUBS DELETE] | +// | | | // //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) { - xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseNoTransaction") - subReqCount := 1 - parameterSet := 1 // E2SM-gNB-X2 - actionDefinitionPresent := true - actionParamCount := 1 + xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseNoTransaction") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, + Counter{cSubReqToE2, 1}, + Counter{cSubReqTimerExpiry, 2}, + Counter{cSubReReqToE2, 1}, + Counter{cSubRespFromE2, 1}, + Counter{cSubFailFromE2, 1}, + Counter{cRestSubFailNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, + Counter{cSubDelReqToE2, 1}, + Counter{cSubDelReqTimerExpiry, 2}, + Counter{cSubDelReReqToE2, 1}, + Counter{cSubDelRespFromE2, 2}, + }) + + const subReqCount int = 1 // Req - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) crereq, cremsg := e2termConn1.RecvSubsReq(t) @@ -5099,7 +6265,7 @@ func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) { _, cremsg = e2termConn1.RecvSubsReq(t) - xappConn1.ExpectRESTNotification(t, restSubId) + xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") // Subscription already created in E2 Node. fparams := &teststube2ap.E2StubSubsFailParams{} @@ -5115,7 +6281,9 @@ func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) { e2termConn1.SendSubsDelResp(t, delreq, delmsg) instanceId := xappConn1.WaitRESTNotification(t, restSubId) - xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId) + xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId) + + xappConn1.SendRESTSubsDelReq(t, &restSubId) // Wait that subs is cleaned mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10) @@ -5123,7 +6291,8 @@ func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) { xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) - + mainCtrl.VerifyAllClean(t) + mainCtrl.VerifyCounterValues(t) } //----------------------------------------------------------------------------- @@ -5144,7 +6313,7 @@ func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) { // | |------------->| // | | | // | | SubFail | ASN.1 decode fails -// | |<-------------| +// | |<-------------| Decode failed. More data needed. This will result timer expiry and resending // | | | // | | SubReq | // | |------------->| @@ -5153,22 +6322,30 @@ func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) { // | |<-------------| // | RESTNotif (fail)| | // |<----------------| | -// | | SubDelReq | -// | |------------->| // | | | -// | | SubDelResp | -// | |<-------------| +// | [SUBS DELETE] | +// | | | // //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) { - xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureDecodeFail") - subReqCount := 1 - parameterSet := 1 // E2SM-gNB-X2 - actionDefinitionPresent := true - actionParamCount := 1 + xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureDecodeFail") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, + Counter{cSubReqToE2, 1}, + Counter{cSubReqTimerExpiry, 1}, + Counter{cSubReReqToE2, 1}, + Counter{cSubFailFromE2, 2}, + Counter{cRestSubFailNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, + }) + + const subReqCount int = 1 // Req - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) crereq, cremsg := e2termConn1.RecvSubsReq(t) @@ -5178,7 +6355,7 @@ func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) { _, cremsg = e2termConn1.RecvSubsReq(t) - xappConn1.ExpectRESTNotification(t, restSubId) + xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") // Subscription already created in E2 Node. fparams := &teststube2ap.E2StubSubsFailParams{} @@ -5186,11 +6363,10 @@ func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) { 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) + xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId) + + xappConn1.SendRESTSubsDelReq(t, &restSubId) // Wait that subs is cleaned mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10) @@ -5198,6 +6374,8 @@ func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) { xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) + mainCtrl.VerifyAllClean(t) + mainCtrl.VerifyCounterValues(t) } //----------------------------------------------------------------------------- @@ -5218,13 +6396,13 @@ func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) { // | |------------->| // | | | // | | SubFail | Unknown instanceId -// | |<-------------| +// | |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending // | | | // | | SubReq | // | |------------->| // | | | // | | SubFail | Duplicated action -// | |<-------------| +// | |<-------------|No valid subscription found with subIds [0]. This will result timer expiry and sending delete // | RESTNotif (fail)| | // |<----------------| | // | | SubDelReq | @@ -5232,22 +6410,36 @@ func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) { // | | | // | | SubDelResp | // | |<-------------| +// | | | +// | [SUBS DELETE] | +// | | | // //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) { - xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId") - subReqCount := 1 - parameterSet := 1 // E2SM-gNB-X2 - actionDefinitionPresent := true - actionParamCount := 1 + xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId") + const subReqCount int = 1 + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, + Counter{cSubReqToE2, 1}, + Counter{cSubReqTimerExpiry, 2}, + Counter{cSubReReqToE2, 1}, + Counter{cSubFailFromE2, 2}, + Counter{cRestSubFailNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, + Counter{cSubDelReqToE2, 1}, + Counter{cSubDelRespFromE2, 1}, + }) // Req - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + 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 + // Unknown instanceId 0 in this response which will result resending original request fparams := &teststube2ap.E2StubSubsFailParams{} fparams.Set(crereq) fparams.Fail.RequestId.InstanceId = 0 @@ -5255,9 +6447,9 @@ func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) { _, cremsg = e2termConn1.RecvSubsReq(t) - xappConn1.ExpectRESTNotification(t, restSubId) + xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") - // Subscription already created in E2 Node. + // Subscription already created in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action e2termConn1.SendSubsFail(t, fparams, cremsg) @@ -5265,7 +6457,9 @@ func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) { e2termConn1.SendSubsDelResp(t, delreq, delmsg) instanceId := xappConn1.WaitRESTNotification(t, restSubId) - xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId) + xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId) + + xappConn1.SendRESTSubsDelReq(t, &restSubId) // Wait that subs is cleaned mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10) @@ -5273,6 +6467,8 @@ func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) { xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) + mainCtrl.VerifyAllClean(t) + mainCtrl.VerifyCounterValues(t) } //----------------------------------------------------------------------------- @@ -5293,31 +6489,53 @@ func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) { // | |------------->| // | | | // | | SubFail | No transaction for the response -// | |<-------------| +// | |<-------------| Ongoing transaction not found. This will result timer expiry and resending // | | | // | | SubReq | // | |------------->| // | | | // | | SubFail | Duplicated action -// | |<-------------| +// | |<-------------| Ongoing transaction not found. This will result timer expiry and sending delete // | RESTNotif (fail)| | // |<----------------| | // | | SubDelReq | // | |------------->| // | | | // | | SubDelResp | -// | |<-------------| +// | |<-------------| Ongoing transaction not found. This will result timer expiry and resending +// | | | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelResp | +// | |<-------------| Ongoing transaction not found. +// | | | +// | [SUBS DELETE] | +// | | | // //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) { - xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureNoTransaction") - subReqCount := 1 - parameterSet := 1 // E2SM-gNB-X2 - actionDefinitionPresent := true - actionParamCount := 1 + xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureNoTransaction") + const subReqCount int = 1 + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, + Counter{cSubReqToE2, 1}, + Counter{cSubReqTimerExpiry, 2}, + Counter{cSubReReqToE2, 1}, + Counter{cSubFailFromE2, 2}, + Counter{cRestSubFailNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, + Counter{cSubDelReqToE2, 1}, + Counter{cSubDelReqTimerExpiry, 2}, + Counter{cSubDelReReqToE2, 1}, + Counter{cSubDelRespFromE2, 2}, + }) // Req - params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount) + params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) crereq, cremsg := e2termConn1.RecvSubsReq(t) @@ -5331,7 +6549,7 @@ func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) { _, cremsg = e2termConn1.RecvSubsReq(t) - xappConn1.ExpectRESTNotification(t, restSubId) + xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") // Subscription already created in E2 Node. fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action @@ -5345,7 +6563,9 @@ func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) { e2termConn1.SendSubsDelResp(t, delreq, delmsg) instanceId := xappConn1.WaitRESTNotification(t, restSubId) - xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId) + xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId) + + xappConn1.SendRESTSubsDelReq(t, &restSubId) // Wait that subs is cleaned mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10) @@ -5353,6 +6573,8 @@ func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) { xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) + mainCtrl.VerifyAllClean(t) + mainCtrl.VerifyCounterValues(t) } //----------------------------------------------------------------------------- @@ -5375,19 +6597,36 @@ func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) { // | | SubDelReq | // | |------------->| // | | | -// | | SubDelResp | ASN.1 decode fails -// | |<-------------| +// | | SubDelResp | ASN.1 decode fails. +// | |<-------------| Decode failed. More data needed. This will result timer expiry and resending // | | | // | | SubDelReq | // | |------------->| // | | | -// | | SubDelFail | Subscription does exist any more +// | | SubDelFail | Subscription does exist any more in E2 node // | |<-------------| // | | | +// | [SUBS DELETE] | +// | | | // //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) { - xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail") + xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, + Counter{cSubReqToE2, 1}, + Counter{cSubRespFromE2, 1}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, + Counter{cSubDelReqToE2, 1}, + Counter{cSubDelReqTimerExpiry, 1}, + Counter{cSubDelReReqToE2, 1}, + Counter{cSubDelFailFromE2, 1}, + Counter{cSubDelRespFromE2, 1}, + }) // Req var params *teststube2ap.RESTSubsReqParams = nil @@ -5400,7 +6639,7 @@ func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) { 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) + e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_RESP) // E2t: Receive 2nd SubsDelReq and send SubsDelResp delreq, delmsg = e2termConn1.RecvSubsDelReq(t) @@ -5414,6 +6653,8 @@ func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) { xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) + mainCtrl.VerifyAllClean(t) + mainCtrl.VerifyCounterValues(t) } //----------------------------------------------------------------------------- @@ -5437,17 +6678,34 @@ func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) { // | |------------->| // | | | // | | SubDelResp | Unknown instanceId -// | |<-------------| +// | |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending // | | | // | | SubDelReq | // | |------------->| // | | | -// | | SubDelFail | Subscription does exist any more +// | | SubDelFail | Subscription does exist any more in E2 node // | |<-------------| -// +// | | | +// | [SUBS DELETE] | +// | | | //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) { - xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId") + xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, + Counter{cSubReqToE2, 1}, + Counter{cSubRespFromE2, 1}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, + Counter{cSubDelReqToE2, 1}, + Counter{cSubDelReqTimerExpiry, 1}, + Counter{cSubDelReReqToE2, 1}, + Counter{cSubDelRespFromE2, 1}, + Counter{cSubDelFailFromE2, 1}, + }) // Req var params *teststube2ap.RESTSubsReqParams = nil @@ -5475,6 +6733,8 @@ func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) { xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) + mainCtrl.VerifyAllClean(t) + mainCtrl.VerifyCounterValues(t) } //----------------------------------------------------------------------------- @@ -5498,17 +6758,34 @@ func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) { // | |------------->| // | | | // | | SubDelResp | No transaction for the response -// | |<-------------| +// | |<-------------| Ongoing transaction not found. This will result timer expiry and resending // | | | // | | SubDelReq | // | |------------->| // | | | -// | | SubDelFail | Subscription does exist any more -// | |<-------------| -// +// | | SubDelFail | Subscription does exist any more in E2 node +// | |<-------------| Ongoing transaction not found. This will result timer expiry +// | | | +// | [SUBS DELETE] | +// | | | //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) { - xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction") + xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, + Counter{cSubReqToE2, 1}, + Counter{cSubRespFromE2, 1}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, + Counter{cSubDelReqToE2, 1}, + Counter{cSubDelReqTimerExpiry, 2}, + Counter{cSubDelReReqToE2, 1}, + Counter{cSubDelRespFromE2, 1}, + Counter{cSubDelFailFromE2, 1}, + }) // Req var params *teststube2ap.RESTSubsReqParams = nil @@ -5537,6 +6814,8 @@ func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) { xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) + mainCtrl.VerifyAllClean(t) + mainCtrl.VerifyCounterValues(t) } //----------------------------------------------------------------------------- @@ -5560,17 +6839,33 @@ func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) { // | |------------->| // | | | // | | SubDelFail | ASN.1 decode fails -// | |<-------------| +// | |<-------------| Decode failed. More data needed. This will result timer expiry and resending // | | | // | | SubDelReq | // | |------------->| // | | | -// | | SubDelFail | Subscription does exist any more +// | | SubDelFail | Subscription does exist any more in E2 node // | |<-------------| -// +// | | | +// | [SUBS DELETE] | +// | | | //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) { - xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail") + xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, + Counter{cSubReqToE2, 1}, + Counter{cSubRespFromE2, 1}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, + Counter{cSubDelReqToE2, 1}, + Counter{cSubDelReqTimerExpiry, 1}, + Counter{cSubDelReReqToE2, 1}, + Counter{cSubDelFailFromE2, 2}, + }) // Req var params *teststube2ap.RESTSubsReqParams = nil @@ -5597,6 +6892,8 @@ func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) { xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) + mainCtrl.VerifyAllClean(t) + mainCtrl.VerifyCounterValues(t) } //----------------------------------------------------------------------------- @@ -5620,17 +6917,33 @@ func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) { // | |------------->| // | | | // | | SubDelFail | Unknown instanceId -// | |<-------------| +// | |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending // | | | // | | SubDelReq | // | |------------->| // | | | -// | | SubDelFail | Subscription does exist any more -// | |<-------------| -// +// | | SubDelFail | Subscription does exist any more in E2 node +// | |<-------------| No valid subscription found with subIds [0]. +// | | | +// | [SUBS DELETE] | +// | | | //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) { - xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId") + xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, + Counter{cSubReqToE2, 1}, + Counter{cSubRespFromE2, 1}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, + Counter{cSubDelReqToE2, 1}, + Counter{cSubDelReqTimerExpiry, 1}, + Counter{cSubDelReReqToE2, 1}, + Counter{cSubDelFailFromE2, 2}, + }) // Req var params *teststube2ap.RESTSubsReqParams = nil @@ -5642,14 +6955,14 @@ func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) { // E2t: Receive 1st SubsDelReq delreq, delmsg := e2termConn1.RecvSubsDelReq(t) - // Unknown instanceId in this response which will result resending original request + // Unknown instanceId 0 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. + // Subscription does not exist in in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0 e2termConn1.SendSubsDelFail(t, delreq, delmsg) // Wait that subs is cleaned @@ -5658,6 +6971,8 @@ func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) { xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) + mainCtrl.VerifyAllClean(t) + mainCtrl.VerifyCounterValues(t) } //----------------------------------------------------------------------------- @@ -5681,17 +6996,33 @@ func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) { // | |------------->| // | | | // | | SubDelFail | No transaction for the response -// | |<-------------| +// | |<-------------| Ongoing transaction not found. This will result timer expiry and resending // | | | // | | SubDelReq | // | |------------->| // | | | -// | | SubDelFail | Subscription does exist any more -// | |<-------------| -// +// | | SubDelFail | Subscription does exist any more in E2 node +// | |<-------------| Ongoing transaction not found. This will result timer expiry +// | | | +// | [SUBS DELETE] | +// | | | //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) { - xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction") + xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, + Counter{cSubReqToE2, 1}, + Counter{cSubRespFromE2, 1}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, + Counter{cSubDelReqToE2, 1}, + Counter{cSubDelReqTimerExpiry, 2}, + Counter{cSubDelReReqToE2, 1}, + Counter{cSubDelFailFromE2, 2}, + }) // Req var params *teststube2ap.RESTSubsReqParams = nil @@ -5720,66 +7051,307 @@ func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) { xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) + mainCtrl.VerifyAllClean(t) + mainCtrl.VerifyCounterValues(t) +} + +//----------------------------------------------------------------------------- +// 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{cRestSubReqFromXapp, 1}, + Counter{cRestSubRespToXapp, 1}, + Counter{cRestSubFailNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cRestSubDelRespToXapp, 1}, + }) + + const subReqCount int = 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.Debug("Send REST subscriber request for subscriberId : %v", restSubId) + + // E2t: Receive SubsDelReq + xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") + + e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) + xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId) + + e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true) + + xappConn1.SendRESTSubsDelReq(t, &restSubId) + + // Wait that subs is cleaned + waitSubsCleanup(t, e2SubsId, 10) + mainCtrl.VerifyAllClean(t) + mainCtrl.VerifyCounterValues(t) +} + +func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) { + CaseBegin("TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 2}, + Counter{cRestSubRespToXapp, 2}, + Counter{cSubReqToE2, 2}, + Counter{cSubReqTimerExpiry, 1}, + Counter{cSubRespFromE2, 1}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubFailNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cSubDelReqToE2, 1}, + Counter{cSubDelRespFromE2, 1}, + Counter{cRestSubDelRespToXapp, 1}, + }) + + const e2Timeout int64 = 1 + const e2RetryCount int64 = 0 + const routingNeeded bool = false + + // Req1 + params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) + params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded) + + // Subs Create + restSubId := xappConn1.SendRESTSubsReq(t, params) + xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId) + + crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) + xappConn1.ExpectRESTNotification(t, restSubId) + e2termConn1.SendSubsResp(t, crereq1, cremsg1) + e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) + xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId) + + // Policy change + params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount) + params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded) + params.SetSubscriptionID(&restSubId) + params.SetTimeToWait("w200ms") + restSubId = xappConn1.SendRESTSubsReq(t, params) + xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId) + + crereq1, cremsg1 = e2termConn1.RecvSubsReq(t) + xappConn1.ExpectRESTNotification(t, restSubId) + // SubsResp is missing, e2SubsId will be 0 + zeroE2SubsId := xappConn1.WaitRESTNotification(t, restSubId) + xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", zeroE2SubsId) + + // Del + xappConn1.SendRESTSubsDelReq(t, &restSubId) + delreq, delmsg := e2termConn1.RecvSubsDelReq(t) + e2termConn1.SendSubsDelResp(t, delreq, delmsg) + + waitSubsCleanup(t, e2SubsId, 10) + mainCtrl.VerifyAllClean(t) + mainCtrl.VerifyCounterValues(t) +} + +//----------------------------------------------------------------------------- +// TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle +// +// stub stub +// +-------+ +---------+ +---------+ +// | xapp | | submgr | | e2term | +// +-------+ +---------+ +---------+ +// | | | +// | RESTSubReq | | +// |---------------->| | +// | | | +// | RESTSubResp | | +// |<----------------| | +// | | SubReq | +// | |------------->| +// | | | +// | | SubResp | +// | |<-------------| +// | | | +// | RESTNotif | | +// |<----------------| | +// | | | +// | RESTSubReq | | +// |---------------->| | +// | | | +// | RESTSubResp | | +// |<----------------| | +// | | SubReq | +// | |------------->| +// | | +// | Submgr restart | +// | | | +// | RESTSubDelReq | | +// |---------------->| | +// | | | +// | | SubDelReq | +// | |------------->| +// | | | +// | | SubDelResp | +// | |<-------------| +// | | | +// | RESTSubDelResp | | +// |<----------------| | +// +//----------------------------------------------------------------------------- + +func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) { + CaseBegin("TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle") + + mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ + Counter{cRestSubReqFromXapp, 2}, + Counter{cRestSubRespToXapp, 2}, + Counter{cSubReqToE2, 2}, + Counter{cSubRespFromE2, 1}, + Counter{cRestSubNotifToXapp, 1}, + Counter{cRestSubDelReqFromXapp, 1}, + Counter{cSubDelReqToE2, 1}, + Counter{cSubDelRespFromE2, 1}, + Counter{cRestSubDelRespToXapp, 1}, + }) + + const e2Timeout int64 = 1 + const e2RetryCount int64 = 0 + const routingNeeded bool = false + + // Req1 + params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) + params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded) + // Create subscription + restSubId := xappConn1.SendRESTSubsReq(t, params) + xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId) + + crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) + xappConn1.ExpectRESTNotification(t, restSubId) + e2termConn1.SendSubsResp(t, crereq1, cremsg1) + e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) + xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId) + + // Check subscription + queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"}) + + // Policy change + params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount) + params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded) + params.SetSubscriptionID(&restSubId) + params.SetTimeToWait("w200ms") + mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription + restSubId = xappConn1.SendRESTSubsReq(t, params) + xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId) + + crereq1, cremsg1 = e2termConn1.RecvSubsReq(t) + mainCtrl.SetResetTestFlag(t, false) + + // SubsResp is missing due to submgr restart + + mainCtrl.SimulateRestart(t) + xapp.Logger.Debug("mainCtrl.SimulateRestart done") + + // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions()) + // That needs to be completed before successful subscription query is possible + <-time.After(time.Second * 1) + + // Check subscription + queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"}) + + // Delete subscription + xappConn1.SendRESTSubsDelReq(t, &restSubId) + delreq, delmsg := e2termConn1.RecvSubsDelReq(t) + e2termConn1.SendSubsDelResp(t, delreq, delmsg) + + //Wait that subs is cleaned + waitSubsCleanup(t, e2SubsId, 10) + + mainCtrl.VerifyCounterValues(t) + mainCtrl.VerifyAllClean(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) + xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId) crereq1, cremsg1 := toE2termConn.RecvSubsReq(t) fromXappConn.ExpectRESTNotification(t, restSubId) toE2termConn.SendSubsResp(t, crereq1, cremsg1) e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId) - xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId) + xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId) return restSubId, e2SubsId } 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) } xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler) restSubId := xappConn2.SendRESTSubsReq(t, params) xappConn2.ExpectRESTNotification(t, restSubId) - xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId) + xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId) e2SubsId := xappConn2.WaitRESTNotification(t, restSubId) - xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId) + xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId) return restSubId, e2SubsId } 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) + xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId) crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) xappConn1.ExpectRESTNotification(t, restSubId) e2termConn1.SendSubsResp(t, crereq1, cremsg1) e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) - xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId) + xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId) return restSubId, e2SubsId } 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) @@ -5791,7 +7363,7 @@ func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) { xappConn1.ExpectRESTNotification(t, restSubId) e2termConn1.SendSubsDelResp(t, delreq1, delmsg1) e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) - xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId) + xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId) return restSubId, e2SubsId } @@ -5816,9 +7388,9 @@ func deleteXapp2Subscription(t *testing.T, restSubId *string) { func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) { resp, _ := xapp.Subscription.QuerySubscriptions() - assert.Equal(t, resp[0].SubscriptionID, e2SubsId) - assert.Equal(t, resp[0].Meid, meid) - assert.Equal(t, resp[0].ClientEndpoint, endpoint) + assert.Equal(t, e2SubsId, resp[0].SubscriptionID) + assert.Equal(t, meid, resp[0].Meid) + assert.Equal(t, endpoint, resp[0].ClientEndpoint) } func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) { @@ -5836,14 +7408,14 @@ func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *test var e2SubsId []uint32 for i := 0; i < count; i++ { - xapp.Logger.Info("TEST: %d ===================================== BEGIN CRE ============================================", i+1) + xapp.Logger.Debug("TEST: %d ===================================== BEGIN CRE ============================================", i+1) crereq, cremsg := toE2termConn.RecvSubsReq(t) fromXappConn.ExpectRESTNotification(t, restSubId) toE2termConn.SendSubsResp(t, crereq, cremsg) instanceId := fromXappConn.WaitRESTNotification(t, restSubId) e2SubsId = append(e2SubsId, instanceId) - xapp.Logger.Info("TEST: %v", e2SubsId) - xapp.Logger.Info("TEST: %d ===================================== END CRE ============================================", i+1) + xapp.Logger.Debug("TEST: %v", e2SubsId) + xapp.Logger.Debug("TEST: %d ===================================== END CRE ============================================", i+1) <-time.After(100 * time.Millisecond) } return e2SubsId @@ -5852,11 +7424,11 @@ func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *test func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) { for i := 0; i < len(e2SubsIds); i++ { - xapp.Logger.Info("TEST: %d ===================================== BEGIN DEL ============================================", i+1) + xapp.Logger.Debug("TEST: %d ===================================== BEGIN DEL ============================================", i+1) delreq, delmsg := toE2termConn.RecvSubsDelReq(t) toE2termConn.SendSubsDelResp(t, delreq, delmsg) <-time.After(1 * time.Second) - xapp.Logger.Info("TEST: %d ===================================== END DEL ============================================", i+1) + xapp.Logger.Debug("TEST: %d ===================================== END DEL ============================================", i+1) <-time.After(100 * time.Millisecond) }