| /* |
| ================================================================================== |
| Copyright (c) 2019 AT&T Intellectual Property. |
| Copyright (c) 2019 Nokia |
| |
| Licensed under the Apache License, Version 2.0 (the "License"); |
| you may not use this file except in compliance with the License. |
| You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| ================================================================================== |
| */ |
| |
| package control |
| |
| import ( |
| "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/submgr/pkg/teststube2ap" |
| "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp" |
| "github.com/stretchr/testify/assert" |
| ) |
| |
| func TestSuiteSetup(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:git log |
| // SetPackerIf(e2ap_wrapper.NewAsn1E2APPacker()) |
| |
| SetPackerIf(e2ap_wrapper.NewUtAsn1E2APPacker()) |
| |
| mainCtrl.c.restDuplicateCtrl.Init() |
| |
| } |
| |
| //----------------------------------------------------------------------------- |
| // 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) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // 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) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // 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) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqAndRouteNok |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | rtmgr | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | SubReq | | |
| // |------------->| | |
| // | | | |
| // | | RouteCreate | |
| // | |------------->| |
| // | | | |
| // | | RouteCreate | |
| // | | status:400 | |
| // | |<-------------| |
| // | | | |
| // | [SUBS INT DELETE] | |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| |
| func TestSubReqAndRouteNok(t *testing.T) { |
| CaseBegin("TestSubReqAndRouteNok") |
| |
| // Init counter check |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cSubReqFromXapp, 1}, |
| Counter{cRouteCreateFail, 1}, |
| }) |
| |
| waiter := rtmgrHttp.AllocNextEvent(false) |
| newSubsId := mainCtrl.get_registry_next_subid(t) |
| xappConn1.SendSubsReq(t, nil, nil) |
| waiter.WaitResult(t) |
| |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, newSubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| |
| <-time.After(1 * time.Second) |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqAndRouteUpdateNok |
| |
| // stub stub |
| // +-------+ +-------+ +---------+ +---------+ |
| // | xapp2 | | xapp1 | | submgr | | rtmgr | |
| // +-------+ +-------+ +---------+ +---------+ |
| // | | | | |
| // | [SUBS CREATE] | | |
| // | | | | |
| // | | | | |
| // | | | | |
| // | SubReq (mergeable) | | |
| // |--------------------------->| | | |
| // | | | | |
| // | | | RouteUpdate | |
| // | | |------------->| |
| // | | | | |
| // | | | RouteUpdate | |
| // | | | status:400 | |
| // | | |<-------------| |
| // | | | | |
| // | [SUBS INT DELETE] | | |
| // | | | | |
| // | | | | |
| // | [SUBS DELETE] | | |
| // | | | | |
| |
| func TestSubReqAndRouteUpdateNok(t *testing.T) { |
| CaseBegin("TestSubReqAndRouteUpdateNok") |
| |
| // Init counter check |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cSubReqFromXapp, 2}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubRespFromE2, 1}, |
| Counter{cSubRespToXapp, 1}, |
| Counter{cRouteCreateUpdateFail, 1}, |
| Counter{cSubDelReqFromXapp, 1}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| Counter{cSubDelRespToXapp, 1}, |
| }) |
| |
| cretrans := xappConn1.SendSubsReq(t, nil, nil) |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| e2SubsId := xappConn1.RecvSubsResp(t, cretrans) |
| |
| resp, _ := xapp.Subscription.QuerySubscriptions() |
| assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId)) |
| assert.Equal(t, resp[0].Meid, "RAN_NAME_1") |
| assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"}) |
| |
| waiter := rtmgrHttp.AllocNextEvent(false) |
| newSubsId := mainCtrl.get_registry_next_subid(t) |
| xappConn2.SendSubsReq(t, nil, nil) |
| waiter.WaitResult(t) |
| |
| deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId) |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| xappConn1.RecvSubsDelResp(t, deltrans) |
| |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, newSubsId, 10) |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubDelReqAndRouteDeleteNok |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | | rtmgr | |
| // +-------+ +---------+ +---------+ +---------+ |
| // | | | | |
| // | [SUBS CREATE] | | |
| // | | | | |
| // | | | | |
| // | | | | |
| // | SubDelReq | | | |
| // |------------->| | | |
| // | | SubDelReq | | |
| // | |------------->| | |
| // | | SubDelRsp | | |
| // | |<-------------| | |
| // | SubDelRsp | | | |
| // |<-------------| | | |
| // | | RouteDelete | | |
| // | |---------------------------->| |
| // | | | | |
| // | | RouteDelete | | |
| // | | status:400 | | |
| // | |<----------------------------| |
| // | | | | |
| func TestSubDelReqAndRouteDeleteNok(t *testing.T) { |
| CaseBegin("TestSubDelReqAndRouteDeleteNok") |
| |
| // Init counter check |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cSubReqFromXapp, 1}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubRespFromE2, 1}, |
| Counter{cSubRespToXapp, 1}, |
| Counter{cSubDelReqFromXapp, 1}, |
| Counter{cRouteDeleteFail, 1}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| Counter{cSubDelRespToXapp, 1}, |
| }) |
| |
| cretrans := xappConn1.SendSubsReq(t, nil, nil) |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| e2SubsId := xappConn1.RecvSubsResp(t, cretrans) |
| |
| resp, _ := xapp.Subscription.QuerySubscriptions() |
| assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId)) |
| assert.Equal(t, resp[0].Meid, "RAN_NAME_1") |
| assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"}) |
| |
| deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId) |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| |
| waiter := rtmgrHttp.AllocNextEvent(false) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| waiter.WaitResult(t) |
| |
| xappConn1.RecvSubsDelResp(t, deltrans) |
| |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubMergeDelAndRouteUpdateNok |
| // stub stub |
| // +-------+ +-------+ +---------+ +---------+ |
| // | xapp2 | | xapp1 | | submgr | | e2term | |
| // +-------+ +-------+ +---------+ +---------+ |
| // | | | | |
| // | | | | |
| // | | | | |
| // | | SubReq1 | | |
| // | |------------->| | |
| // | | | | |
| // | | | SubReq1 | |
| // | | |------------->| |
| // | | | SubResp1 | |
| // | | |<-------------| |
| // | | SubResp1 | | |
| // | |<-------------| | |
| // | | | | |
| // | SubReq2 | | |
| // |--------------------------->| | |
| // | | | | |
| // | SubResp2 | | |
| // |<---------------------------| | |
| // | | | | |
| // | | SubDelReq 1 | | |
| // | |------------->| | |
| // | | | RouteUpdate | |
| // | | |-----> rtmgr | |
| // | | | | |
| // | | | RouteUpdate | |
| // | | | status:400 | |
| // | | |<----- rtmgr | |
| // | | | | |
| // | | SubDelResp 1 | | |
| // | |<-------------| | |
| // | | | | |
| // | SubDelReq 2 | | |
| // |--------------------------->| | |
| // | | | | |
| // | | | SubDelReq 2 | |
| // | | |------------->| |
| // | | | | |
| // | | | SubDelReq 2 | |
| // | | |------------->| |
| // | | | | |
| // | SubDelResp 2 | | |
| // |<---------------------------| | |
| // |
| //----------------------------------------------------------------------------- |
| func TestSubMergeDelAndRouteUpdateNok(t *testing.T) { |
| CaseBegin("TestSubMergeDelAndRouteUpdateNok") |
| |
| // Init counter check |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cSubReqFromXapp, 2}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubRespFromE2, 1}, |
| Counter{cSubRespToXapp, 2}, |
| Counter{cSubDelReqFromXapp, 2}, |
| Counter{cRouteDeleteUpdateFail, 1}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| Counter{cSubDelRespToXapp, 2}, |
| }) |
| |
| //Req1 |
| rparams1 := &teststube2ap.E2StubSubsReqParams{} |
| rparams1.Init() |
| cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil) |
| crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq1, cremsg1) |
| e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1) |
| |
| //Req2 |
| rparams2 := &teststube2ap.E2StubSubsReqParams{} |
| rparams2.Init() |
| cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil) |
| e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2) |
| |
| 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"}) |
| |
| //Del1 |
| waiter := rtmgrHttp.AllocNextEvent(false) |
| deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1) |
| waiter.WaitResult(t) |
| |
| xappConn1.RecvSubsDelResp(t, deltrans1) |
| |
| //Del2 |
| deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2) |
| delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq2, delmsg2) |
| xappConn2.RecvSubsDelResp(t, deltrans2) |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId2, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqAndSubDelOk |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | SubReq | | |
| // |------------->| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubResp | |
| // | |<-------------| |
| // | | | |
| // | SubResp | | |
| // |<-------------| | |
| // | | | |
| // | | | |
| // | SubDelReq | | |
| // |------------->| | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | | | |
| // | SubDelResp | | |
| // |<-------------| | |
| // |
| //----------------------------------------------------------------------------- |
| func TestSubReqAndSubDelOk(t *testing.T) { |
| CaseBegin("TestSubReqAndSubDelOk") |
| |
| // Init counter check |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cSubReqFromXapp, 1}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubRespFromE2, 1}, |
| Counter{cSubRespToXapp, 1}, |
| Counter{cSubDelReqFromXapp, 1}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| Counter{cSubDelRespToXapp, 1}, |
| }) |
| |
| cretrans := xappConn1.SendSubsReq(t, nil, nil) |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| e2SubsId := xappConn1.RecvSubsResp(t, cretrans) |
| |
| resp, _ := xapp.Subscription.QuerySubscriptions() |
| assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId)) |
| assert.Equal(t, resp[0].Meid, "RAN_NAME_1") |
| assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"}) |
| |
| deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId) |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| xappConn1.RecvSubsDelResp(t, deltrans) |
| |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqRetransmission |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | SubReq | | |
| // |------------->| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | SubReq | | |
| // | (retrans) | | |
| // |------------->| | |
| // | | | |
| // | | SubResp | |
| // | |<-------------| |
| // | | | |
| // | SubResp | | |
| // |<-------------| | |
| // | | | |
| // | [SUBS DELETE] | |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| func TestSubReqRetransmission(t *testing.T) { |
| CaseBegin("TestSubReqRetransmission") |
| |
| //Subs Create |
| cretrans := xappConn1.SendSubsReq(t, nil, nil) |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| |
| seqBef := mainCtrl.get_msgcounter(t) |
| xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq |
| mainCtrl.wait_msgcounter_change(t, seqBef, 10) |
| |
| // hack as there is no real way to see has message be handled. |
| // Previuos counter check just tells that is has been received by submgr |
| // --> artificial delay |
| <-time.After(1 * time.Second) |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| e2SubsId := xappConn1.RecvSubsResp(t, cretrans) |
| |
| //Subs Delete |
| deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId) |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| xappConn1.RecvSubsDelResp(t, deltrans) |
| |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubDelReqRetransmission |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | [SUBS CREATE] | |
| // | | | |
| // | | | |
| // | SubDelReq | | |
| // |------------->| | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | SubDelReq | | |
| // | (same sub) | | |
| // | (same xid) | | |
| // |------------->| | |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | | | |
| // | SubDelResp | | |
| // |<-------------| | |
| // |
| //----------------------------------------------------------------------------- |
| func TestSubDelReqRetransmission(t *testing.T) { |
| CaseBegin("TestSubDelReqRetransmission") |
| |
| //Subs Create |
| cretrans := xappConn1.SendSubsReq(t, nil, nil) |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| e2SubsId := xappConn1.RecvSubsResp(t, cretrans) |
| |
| //Subs Delete |
| deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId) |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| |
| seqBef := mainCtrl.get_msgcounter(t) |
| xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq |
| mainCtrl.wait_msgcounter_change(t, seqBef, 10) |
| |
| // hack as there is no real way to see has message be handled. |
| // Previuos counter check just tells that is has been received by submgr |
| // --> artificial delay |
| <-time.After(1 * time.Second) |
| |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| xappConn1.RecvSubsDelResp(t, deltrans) |
| |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubDelReqCollision |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | [SUBS CREATE] | |
| // | | | |
| // | | | |
| // | SubDelReq 1 | | |
| // |------------->| | |
| // | | | |
| // | | SubDelReq 1 | |
| // | |------------->| |
| // | | | |
| // | SubDelReq 2 | | |
| // | (same sub) | | |
| // | (diff xid) | | |
| // |------------->| | |
| // | | | |
| // | | SubDelResp 1 | |
| // | |<-------------| |
| // | | | |
| // | SubDelResp 1 | | |
| // |<-------------| | |
| // | | | |
| // | SubDelResp 2 | | |
| // |<-------------| | |
| // |
| //----------------------------------------------------------------------------- |
| |
| func TestSubDelReqCollision(t *testing.T) { |
| CaseBegin("TestSubDelReqCollision") |
| |
| //Subs Create |
| cretrans := xappConn1.SendSubsReq(t, nil, nil) |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| e2SubsId := xappConn1.RecvSubsResp(t, cretrans) |
| |
| //Subs Delete |
| xappConn1.SendSubsDelReq(t, nil, e2SubsId) |
| delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t) |
| |
| // Subs Delete colliding |
| seqBef := mainCtrl.get_msgcounter(t) |
| deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1") |
| xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq |
| mainCtrl.wait_msgcounter_change(t, seqBef, 10) |
| |
| // hack as there is no real way to see has message be handled. |
| // Previuos counter check just tells that is has been received by submgr |
| // --> artificial delay |
| <-time.After(1 * time.Second) |
| |
| // Del resp for first and second |
| e2termConn1.SendSubsDelResp(t, delreq1, delmsg1) |
| |
| // don't care in which order responses are received |
| xappConn1.RecvSubsDelResp(t, nil) |
| xappConn1.RecvSubsDelResp(t, nil) |
| |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqAndSubDelOkTwoParallel |
| // |
| // stub stub stub |
| // +-------+ +-------+ +---------+ +---------+ |
| // | xapp | | xapp | | submgr | | e2term | |
| // +-------+ +-------+ +---------+ +---------+ |
| // | | | | |
| // | | | | |
| // | | | | |
| // | | SubReq1 | | |
| // | |------------->| | |
| // | | | | |
| // | | | SubReq1 | |
| // | | |------------->| |
| // | | | | |
| // | SubReq2 | | |
| // |------------------------>| | |
| // | | | | |
| // | | | SubReq2 | |
| // | | |------------->| |
| // | | | | |
| // | | | SubResp1 | |
| // | | |<-------------| |
| // | | SubResp1 | | |
| // | |<-------------| | |
| // | | | | |
| // | | | SubResp2 | |
| // | | |<-------------| |
| // | SubResp2 | | |
| // |<------------------------| | |
| // | | | | |
| // | | [SUBS 1 DELETE] | |
| // | | | | |
| // | | [SUBS 2 DELETE] | |
| // | | | | |
| // |
| //----------------------------------------------------------------------------- |
| |
| func TestSubReqAndSubDelOkTwoParallel(t *testing.T) { |
| CaseBegin("TestSubReqAndSubDelOkTwoParallel") |
| |
| //Req1 |
| rparams1 := &teststube2ap.E2StubSubsReqParams{} |
| rparams1.Init() |
| cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil) |
| crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) |
| |
| //Req2 |
| rparams2 := &teststube2ap.E2StubSubsReqParams{} |
| rparams2.Init() |
| |
| rparams2.Req.EventTriggerDefinition.Data.Length = 1 |
| rparams2.Req.EventTriggerDefinition.Data.Data = make([]uint8, rparams2.Req.EventTriggerDefinition.Data.Length) |
| rparams2.Req.EventTriggerDefinition.Data.Data[0] = 2 |
| |
| cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil) |
| crereq2, cremsg2 := e2termConn1.RecvSubsReq(t) |
| |
| //Resp1 |
| e2termConn1.SendSubsResp(t, crereq1, cremsg1) |
| e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1) |
| |
| //Resp2 |
| e2termConn1.SendSubsResp(t, crereq2, cremsg2) |
| e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2) |
| |
| //Del1 |
| deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1) |
| delreq1, delmsg1 := 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) |
| delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq2, delmsg2) |
| xappConn2.RecvSubsDelResp(t, deltrans2) |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId2, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSameSubsDiffRan |
| // Same subscription to different RANs |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | | | |
| // | | | |
| // | SubReq(r1) | | |
| // |------------->| | |
| // | | | |
| // | | SubReq(r1) | |
| // | |------------->| |
| // | | | |
| // | | SubResp(r1) | |
| // | |<-------------| |
| // | | | |
| // | SubResp(r1) | | |
| // |<-------------| | |
| // | | | |
| // | SubReq(r2) | | |
| // |------------->| | |
| // | | | |
| // | | SubReq(r2) | |
| // | |------------->| |
| // | | | |
| // | | SubResp(r2) | |
| // | |<-------------| |
| // | | | |
| // | SubResp(r2) | | |
| // |<-------------| | |
| // | | | |
| // | [SUBS r1 DELETE] | |
| // | | | |
| // | [SUBS r2 DELETE] | |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| func TestSameSubsDiffRan(t *testing.T) { |
| CaseBegin("TestSameSubsDiffRan") |
| |
| //Req1 |
| cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1") |
| xappConn1.SendSubsReq(t, nil, cretrans1) |
| crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq1, cremsg1) |
| e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1) |
| |
| //Req2 |
| cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2") |
| xappConn1.SendSubsReq(t, nil, cretrans2) |
| crereq2, cremsg2 := e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq2, cremsg2) |
| e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2) |
| |
| //Del1 |
| deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1") |
| xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1) |
| delreq1, delmsg1 := 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 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2") |
| xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2) |
| delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq2, delmsg2) |
| xappConn1.RecvSubsDelResp(t, deltrans2) |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId2, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqRetryInSubmgr |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | SubReq | | |
| // |------------->| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubResp | |
| // | |<-------------| |
| // | | | |
| // | SubResp | | |
| // |<-------------| | |
| // | | | |
| // | [SUBS DELETE] | |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| |
| func TestSubReqRetryInSubmgr(t *testing.T) { |
| CaseBegin("TestSubReqRetryInSubmgr start") |
| |
| // Init counter check |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cSubReqFromXapp, 1}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubReReqToE2, 1}, |
| Counter{cSubRespFromE2, 1}, |
| Counter{cSubRespToXapp, 1}, |
| Counter{cSubDelReqFromXapp, 1}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| Counter{cSubDelRespToXapp, 1}, |
| }) |
| |
| // Xapp: Send SubsReq |
| cretrans := xappConn1.SendSubsReq(t, nil, nil) |
| |
| // E2t: Receive 1st SubsReq |
| e2termConn1.RecvSubsReq(t) |
| |
| // E2t: Receive 2nd SubsReq and send SubsResp |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| |
| // Xapp: Receive SubsResp |
| e2SubsId := xappConn1.RecvSubsResp(t, cretrans) |
| |
| deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId) |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| xappConn1.RecvSubsDelResp(t, deltrans) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | SubReq | | |
| // |------------->| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) { |
| CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start") |
| |
| // Init counter check |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cSubReqFromXapp, 1}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubReReqToE2, 1}, |
| Counter{cSubReqTimerExpiry, 2}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| }) |
| |
| // Xapp: Send SubsReq |
| xappConn1.SendSubsReq(t, nil, nil) |
| |
| // E2t: Receive 1st SubsReq |
| e2termConn1.RecvSubsReq(t) |
| |
| // E2t: Receive 2nd SubsReq |
| e2termConn1.RecvSubsReq(t) |
| |
| // E2t: Send receive SubsDelReq and send SubsResp |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqTwoRetriesNoRespAtAllInSubmgr |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | SubReq | | |
| // |------------->| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| |
| func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) { |
| CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cSubReqFromXapp, 1}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubReReqToE2, 1}, |
| Counter{cSubReqTimerExpiry, 2}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelReReqToE2, 1}, |
| Counter{cSubDelReqTimerExpiry, 2}, |
| }) |
| |
| // Xapp: Send SubsReq |
| xappConn1.SendSubsReq(t, nil, nil) |
| |
| // E2t: Receive 1st SubsReq |
| e2termConn1.RecvSubsReq(t) |
| |
| // E2t: Receive 2nd SubsReq |
| e2termConn1.RecvSubsReq(t) |
| |
| // E2t: Receive 1st SubsDelReq |
| e2termConn1.RecvSubsDelReq(t) |
| |
| // E2t: Receive 2nd SubsDelReq |
| delreq, _ := e2termConn1.RecvSubsDelReq(t) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 15) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqSubFailRespInSubmgr |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | SubReq | | |
| // |------------->| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubFail | |
| // | |<-------------| |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | | | |
| // | SubFail | | |
| // |<-------------| | |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| |
| func TestSubReqSubFailRespInSubmgr(t *testing.T) { |
| CaseBegin("TestSubReqSubFailRespInSubmgr start") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cSubReqFromXapp, 1}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubFailFromE2, 1}, |
| Counter{cSubFailToXapp, 1}, |
| }) |
| |
| // Xapp: Send SubsReq |
| cretrans := xappConn1.SendSubsReq(t, nil, nil) |
| |
| // E2t: Receive SubsReq and send SubsFail (first) |
| crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) |
| fparams1 := &teststube2ap.E2StubSubsFailParams{} |
| 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) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubDelReqRetryInSubmgr |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | [SUBS CREATE] | |
| // | | | |
| // | | | |
| // | SubDelReq | | |
| // |------------->| | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | | | |
| // | SubDelResp | | |
| // |<-------------| | |
| // |
| //----------------------------------------------------------------------------- |
| |
| func TestSubDelReqRetryInSubmgr(t *testing.T) { |
| |
| CaseBegin("TestSubDelReqRetryInSubmgr start") |
| |
| // Subs Create |
| cretrans := xappConn1.SendSubsReq(t, nil, nil) |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| e2SubsId := xappConn1.RecvSubsResp(t, cretrans) |
| |
| // Subs Delete |
| // Xapp: Send SubsDelReq |
| deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId) |
| |
| // E2t: Receive 1st SubsDelReq |
| e2termConn1.RecvSubsDelReq(t) |
| |
| // E2t: Receive 2nd SubsDelReq and send SubsDelResp |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| |
| // Xapp: Receive SubsDelResp |
| xappConn1.RecvSubsDelResp(t, deltrans) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubDelReqTwoRetriesNoRespInSubmgr |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | [SUBS CREATE] | |
| // | | | |
| // | | | |
| // | SubDelReq | | |
| // |------------->| | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | | |
| // | SubDelResp | | |
| // |<-------------| | |
| // |
| //----------------------------------------------------------------------------- |
| |
| func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) { |
| |
| CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start") |
| |
| // Subs Create |
| cretrans := xappConn1.SendSubsReq(t, nil, nil) |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| e2SubsId := xappConn1.RecvSubsResp(t, cretrans) |
| |
| // Subs Delete |
| // Xapp: Send SubsDelReq |
| deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId) |
| |
| // E2t: Receive 1st SubsDelReq |
| e2termConn1.RecvSubsDelReq(t) |
| |
| // E2t: Receive 2nd SubsDelReq |
| e2termConn1.RecvSubsDelReq(t) |
| |
| // Xapp: Receive SubsDelResp |
| xappConn1.RecvSubsDelResp(t, deltrans) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubDelReqSubDelFailRespInSubmgr |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | [SUBS CREATE] | |
| // | | | |
| // | | | |
| // | SubDelReq | | |
| // |------------->| | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelFail | |
| // | |<-------------| |
| // | | | |
| // | SubDelResp | | |
| // |<-------------| | |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| |
| func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) { |
| CaseBegin("TestSubReqSubDelFailRespInSubmgr start") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cSubReqFromXapp, 1}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubRespFromE2, 1}, |
| Counter{cSubRespToXapp, 1}, |
| Counter{cSubDelReqFromXapp, 1}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelFailFromE2, 1}, |
| Counter{cSubDelRespToXapp, 1}, |
| }) |
| |
| // Subs Create |
| cretrans := xappConn1.SendSubsReq(t, nil, nil) |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| e2SubsId := xappConn1.RecvSubsResp(t, cretrans) |
| |
| // Xapp: Send SubsDelReq |
| deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId) |
| |
| // E2t: Send receive SubsDelReq and send SubsDelFail |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelFail(t, delreq, delmsg) |
| |
| // Xapp: Receive SubsDelResp |
| xappConn1.RecvSubsDelResp(t, deltrans) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqAndSubDelOkSameAction |
| // |
| // stub stub |
| // +-------+ +-------+ +---------+ +---------+ |
| // | xapp2 | | xapp1 | | submgr | | e2term | |
| // +-------+ +-------+ +---------+ +---------+ |
| // | | | | |
| // | | | | |
| // | | | | |
| // | | SubReq1 | | |
| // | |------------->| | |
| // | | | | |
| // | | | SubReq1 | |
| // | | |------------->| |
| // | | | SubResp1 | |
| // | | |<-------------| |
| // | | SubResp1 | | |
| // | |<-------------| | |
| // | | | | |
| // | SubReq2 | | |
| // |--------------------------->| | |
| // | | | | |
| // | SubResp2 | | |
| // |<---------------------------| | |
| // | | | | |
| // | | SubDelReq 1 | | |
| // | |------------->| | |
| // | | | | |
| // | | SubDelResp 1 | | |
| // | |<-------------| | |
| // | | | | |
| // | SubDelReq 2 | | |
| // |--------------------------->| | |
| // | | | | |
| // | | | SubDelReq 2 | |
| // | | |------------->| |
| // | | | | |
| // | | | SubDelReq 2 | |
| // | | |------------->| |
| // | | | | |
| // | SubDelResp 2 | | |
| // |<---------------------------| | |
| // |
| //----------------------------------------------------------------------------- |
| func TestSubReqAndSubDelOkSameAction(t *testing.T) { |
| CaseBegin("TestSubReqAndSubDelOkSameAction") |
| |
| // Init counter check |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cSubReqFromXapp, 2}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubRespFromE2, 1}, |
| Counter{cSubRespToXapp, 2}, |
| Counter{cMergedSubscriptions, 1}, |
| Counter{cUnmergedSubscriptions, 1}, |
| Counter{cSubDelReqFromXapp, 2}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| Counter{cSubDelRespToXapp, 2}, |
| }) |
| |
| //Req1 |
| rparams1 := &teststube2ap.E2StubSubsReqParams{} |
| rparams1.Init() |
| cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil) |
| crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq1, cremsg1) |
| e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1) |
| |
| //Req2 |
| 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() |
| 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"}) |
| |
| //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) |
| delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq2, delmsg2) |
| xappConn2.RecvSubsDelResp(t, deltrans2) |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId2, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqAndSubDelOkSameActionParallel |
| // |
| // stub stub stub |
| // +-------+ +-------+ +---------+ +---------+ |
| // | xapp2 | | xapp1 | | submgr | | e2term | |
| // +-------+ +-------+ +---------+ +---------+ |
| // | | | | |
| // | | | | |
| // | | | | |
| // | | SubReq1 | | |
| // | |------------->| | |
| // | | | | |
| // | | | SubReq1 | |
| // | | |------------->| |
| // | SubReq2 | | |
| // |--------------------------->| | |
| // | | | SubResp1 | |
| // | | |<-------------| |
| // | | SubResp1 | | |
| // | |<-------------| | |
| // | | | | |
| // | SubResp2 | | |
| // |<---------------------------| | |
| // | | | | |
| // | | SubDelReq 1 | | |
| // | |------------->| | |
| // | | | | |
| // | | SubDelResp 1 | | |
| // | |<-------------| | |
| // | | | | |
| // | SubDelReq 2 | | |
| // |--------------------------->| | |
| // | | | | |
| // | | | SubDelReq 2 | |
| // | | |------------->| |
| // | | | | |
| // | | | SubDelReq 2 | |
| // | | |------------->| |
| // | | | | |
| // | SubDelResp 2 | | |
| // |<---------------------------| | |
| // |
| //----------------------------------------------------------------------------- |
| func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) { |
| CaseBegin("TestSubReqAndSubDelOkSameActionParallel") |
| |
| //Req1 |
| rparams1 := &teststube2ap.E2StubSubsReqParams{} |
| rparams1.Init() |
| cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil) |
| crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) |
| |
| //Req2 |
| rparams2 := &teststube2ap.E2StubSubsReqParams{} |
| rparams2.Init() |
| cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil) |
| |
| //Resp1 |
| e2termConn1.SendSubsResp(t, crereq1, cremsg1) |
| e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1) |
| |
| //Resp2 |
| e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2) |
| |
| //Del1 |
| deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1) |
| xappConn1.RecvSubsDelResp(t, deltrans1) |
| |
| //Del2 |
| deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2) |
| delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq2, delmsg2) |
| xappConn2.RecvSubsDelResp(t, deltrans2) |
| |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId2, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqAndSubDelNokSameActionParallel |
| // |
| // stub stub stub |
| // +-------+ +-------+ +---------+ +---------+ |
| // | xapp2 | | xapp1 | | submgr | | e2term | |
| // +-------+ +-------+ +---------+ +---------+ |
| // | | | | |
| // | | | | |
| // | | | | |
| // | | SubReq1 | | |
| // | |------------->| | |
| // | | | | |
| // | | | SubReq1 | |
| // | | |------------->| |
| // | SubReq2 | | |
| // |--------------------------->| | |
| // | | | SubFail1 | |
| // | | |<-------------| |
| // | | | | |
| // | | | SubDelReq | |
| // | | |------------->| |
| // | | | SubDelResp | |
| // | | |<-------------| |
| // | | | | |
| // | | SubFail1 | | |
| // | |<-------------| | |
| // | | | | |
| // | SubFail2 | | |
| // |<---------------------------| | |
| // |
| //----------------------------------------------------------------------------- |
| func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) { |
| CaseBegin("TestSubReqAndSubDelNokSameActionParallel") |
| |
| //Req1 |
| rparams1 := &teststube2ap.E2StubSubsReqParams{} |
| rparams1.Init() |
| cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil) |
| |
| // E2t: Receive SubsReq (first) |
| crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) |
| |
| //Req2 |
| rparams2 := &teststube2ap.E2StubSubsReqParams{} |
| rparams2.Init() |
| subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId) |
| cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil) |
| mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10) |
| |
| // E2t: send SubsFail (first) |
| fparams1 := &teststube2ap.E2StubSubsFailParams{} |
| 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 |
| xappConn2.RecvSubsFail(t, cretrans2) |
| |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId1, 15) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqAndSubDelNoAnswerSameActionParallel |
| // |
| // stub stub stub |
| // +-------+ +-------+ +---------+ +---------+ |
| // | xapp2 | | xapp1 | | submgr | | e2term | |
| // +-------+ +-------+ +---------+ +---------+ |
| // | | | | |
| // | | | | |
| // | | | | |
| // | | SubReq1 | | |
| // | |------------->| | |
| // | | | | |
| // | | | SubReq1 | |
| // | | |------------->| |
| // | | SubReq2 | | |
| // |--------------------------->| | |
| // | | | | |
| // | | | SubReq1 | |
| // | | |------------->| |
| // | | | | |
| // | | | | |
| // | | | SubDelReq | |
| // | | |------------->| |
| // | | | | |
| // | | | SubDelResp | |
| // | | |<-------------| |
| // |
| //----------------------------------------------------------------------------- |
| func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) { |
| CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel") |
| |
| //Req1 |
| rparams1 := &teststube2ap.E2StubSubsReqParams{} |
| rparams1.Init() |
| xappConn1.SendSubsReq(t, rparams1, nil) |
| |
| crereq1, _ := e2termConn1.RecvSubsReq(t) |
| |
| //Req2 |
| rparams2 := &teststube2ap.E2StubSubsReqParams{} |
| rparams2.Init() |
| subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId) |
| xappConn2.SendSubsReq(t, rparams2, nil) |
| mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10) |
| |
| //Req1 (retransmitted) |
| e2termConn1.RecvSubsReq(t) |
| |
| delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq1, delmsg1) |
| |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 15) |
| } |
| |
| //----------------------------- Policy cases --------------------------------- |
| //----------------------------------------------------------------------------- |
| // TestSubReqPolicyAndSubDelOk |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | SubReq | | |
| // |------------->| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubResp | |
| // | |<-------------| |
| // | | | |
| // | SubResp | | |
| // |<-------------| | |
| // | | | |
| // | | | |
| // | SubDelReq | | |
| // |------------->| | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | | | |
| // | SubDelResp | | |
| // |<-------------| | |
| // |
| //----------------------------------------------------------------------------- |
| func TestSubReqPolicyAndSubDelOk(t *testing.T) { |
| CaseBegin("TestSubReqAndSubDelOk") |
| |
| rparams1 := &teststube2ap.E2StubSubsReqParams{} |
| rparams1.Init() |
| rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy |
| cretrans := xappConn1.SendSubsReq(t, rparams1, nil) |
| |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| e2SubsId := xappConn1.RecvSubsResp(t, cretrans) |
| deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId) |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| xappConn1.RecvSubsDelResp(t, deltrans) |
| |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqPolicyChangeAndSubDelOk |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | SubReq | | |
| // |------------->| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubResp | |
| // | |<-------------| |
| // | | | |
| // | SubResp | | |
| // |<-------------| | |
| // | | | |
| // | SubReq | | |
| // |------------->| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubResp | |
| // | |<-------------| |
| // | | | |
| // | SubResp | | |
| // |<-------------| | |
| // | | | |
| // | SubDelReq | | |
| // |------------->| | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | | | |
| // | SubDelResp | | |
| // |<-------------| | |
| // |
| //----------------------------------------------------------------------------- |
| |
| func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) { |
| CaseBegin("TestSubReqAndSubDelOk") |
| |
| rparams1 := &teststube2ap.E2StubSubsReqParams{} |
| rparams1.Init() |
| rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy |
| cretrans := xappConn1.SendSubsReq(t, rparams1, nil) |
| |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| e2SubsId := xappConn1.RecvSubsResp(t, cretrans) |
| |
| //Policy change |
| rparams1.Req.RequestId.InstanceId = e2SubsId |
| rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms |
| xappConn1.SendSubsReq(t, rparams1, cretrans) |
| |
| crereq, cremsg = e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| e2SubsId = xappConn1.RecvSubsResp(t, cretrans) |
| deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId) |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| xappConn1.RecvSubsDelResp(t, deltrans) |
| |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqAndSubDelOkTwoE2termParallel |
| // |
| // stub stub stub |
| // +-------+ +---------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term1 | | e2term2 | |
| // +-------+ +---------+ +---------+ +---------+ |
| // | | | | |
| // | | | | |
| // | | | | |
| // | SubReq1 | | | |
| // |------------->| | | |
| // | | | | |
| // | | SubReq1 | | |
| // | |------------->| | |
| // | | | | |
| // | SubReq2 | | | |
| // |------------->| | | |
| // | | | | |
| // | | SubReq2 | | |
| // | |---------------------------->| |
| // | | | | |
| // | | SubResp1 | | |
| // | |<-------------| | |
| // | SubResp1 | | | |
| // |<-------------| | | |
| // | | SubResp2 | | |
| // | |<----------------------------| |
| // | SubResp2 | | | |
| // |<-------------| | | |
| // | | | | |
| // | [SUBS 1 DELETE] | | |
| // | | | | |
| // | [SUBS 2 DELETE] | | |
| // | | | | |
| // |
| //----------------------------------------------------------------------------- |
| func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) { |
| CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel") |
| |
| //Req1 |
| cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1") |
| xappConn1.SendSubsReq(t, nil, cretrans1) |
| crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) |
| |
| cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11") |
| xappConn1.SendSubsReq(t, nil, cretrans2) |
| crereq2, cremsg2 := e2termConn2.RecvSubsReq(t) |
| |
| //Resp1 |
| e2termConn1.SendSubsResp(t, crereq1, cremsg1) |
| e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1) |
| |
| //Resp2 |
| e2termConn2.SendSubsResp(t, crereq2, cremsg2) |
| e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2) |
| |
| //Del1 |
| deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1) |
| delreq1, delmsg1 := 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 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2) |
| delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t) |
| e2termConn2.SendSubsDelResp(t, delreq2, delmsg2) |
| xappConn1.RecvSubsDelResp(t, deltrans2) |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId2, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| e2termConn2.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqInsertAndSubDelOk |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | SubReq | | |
| // |------------->| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubResp | |
| // | |<-------------| |
| // | | | |
| // | SubResp | | |
| // |<-------------| | |
| // | | | |
| // | | | |
| // | SubDelReq | | |
| // |------------->| | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | | | |
| // | SubDelResp | | |
| // |<-------------| | |
| // |
| //----------------------------------------------------------------------------- |
| func TestSubReqInsertAndSubDelOk(t *testing.T) { |
| CaseBegin("TestInsertSubReqAndSubDelOk") |
| |
| rparams1 := &teststube2ap.E2StubSubsReqParams{} |
| rparams1.Init() |
| rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeInsert |
| cretrans := xappConn1.SendSubsReq(t, rparams1, nil) |
| |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| e2SubsId := xappConn1.RecvSubsResp(t, cretrans) |
| deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId) |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| xappConn1.RecvSubsDelResp(t, deltrans) |
| |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqRetransmissionWithSameSubIdDiffXid |
| // |
| // This case simulates case where xApp restarts and starts sending same |
| // subscription requests which have already subscribed successfully |
| |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | SubReq | | |
| // |------------->| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubResp | |
| // | |<-------------| |
| // | | | |
| // | SubResp | | |
| // |<-------------| | |
| // | | | |
| // | xApp restart | | |
| // | | | |
| // | SubReq | | |
| // | (retrans with same xApp generated subid but diff xid) |
| // |------------->| | |
| // | | | |
| // | SubResp | | |
| // |<-------------| | |
| // | | | |
| // | [SUBS DELETE] | |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) { |
| CaseBegin("TestSubReqRetransmissionWithSameSubIdDiffXid") |
| |
| //Subs Create |
| cretrans := xappConn1.SendSubsReq(t, nil, nil) |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| e2SubsId := xappConn1.RecvSubsResp(t, cretrans) |
| |
| // xApp restart here |
| // --> artificial delay |
| <-time.After(1 * time.Second) |
| |
| //Subs Create |
| cretrans = xappConn1.SendSubsReq(t, nil, nil) //Retransmitted SubReq |
| e2SubsId = xappConn1.RecvSubsResp(t, cretrans) |
| |
| //Subs Delete |
| deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId) |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| xappConn1.RecvSubsDelResp(t, deltrans) |
| |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqNokAndSubDelOkWithRestartInMiddle |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | SubReq | | |
| // |------------->| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubResp | |
| // | <----| |
| // | | |
| // | Submgr restart | |
| // | | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| |
| 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) |
| mainCtrl.SetResetTestFlag(t, false) |
| |
| resp, _ := xapp.Subscription.QuerySubscriptions() |
| assert.Equal(t, resp[0].Meid, "RAN_NAME_1") |
| assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"}) |
| e2SubsId := uint32(resp[0].SubscriptionID) |
| t.Logf("e2SubsId = %v", e2SubsId) |
| |
| 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) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqAndSubDelOkWithRestartInMiddle |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | SubReq | | |
| // |------------->| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubResp | |
| // | |<-------------| |
| // | | | |
| // | SubResp | | |
| // |<-------------| | |
| // | | | |
| // | | |
| // | Submgr restart | |
| // | | |
| // | SubDelReq | | |
| // |------------->| | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | | | |
| // | SubDelResp | | |
| // |<-------------| | |
| // |
| //----------------------------------------------------------------------------- |
| |
| func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) { |
| CaseBegin("TestSubReqAndSubDelOkWithRestartInMiddle") |
| |
| cretrans := xappConn1.SendSubsReq(t, nil, nil) |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| e2SubsId := xappConn1.RecvSubsResp(t, cretrans) |
| |
| // Check subscription |
| resp, _ := xapp.Subscription.QuerySubscriptions() |
| assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId)) |
| assert.Equal(t, resp[0].Meid, "RAN_NAME_1") |
| assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"}) |
| |
| mainCtrl.SimulateRestart(t) |
| xapp.Logger.Debug("mainCtrl.SimulateRestart done") |
| |
| // Check that subscription is restored correctly after restart |
| resp, _ = xapp.Subscription.QuerySubscriptions() |
| assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId)) |
| assert.Equal(t, resp[0].Meid, "RAN_NAME_1") |
| assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"}) |
| |
| deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId) |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| xappConn1.RecvSubsDelResp(t, deltrans) |
| |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqAndSubDelOkSameActionWithRestartsInMiddle |
| // |
| // stub stub |
| // +-------+ +-------+ +---------+ +---------+ |
| // | xapp2 | | xapp1 | | submgr | | e2term | |
| // +-------+ +-------+ +---------+ +---------+ |
| // | | | | |
| // | | | | |
| // | | | | |
| // | | SubReq1 | | |
| // | |------------->| | |
| // | | | | |
| // | | | SubReq1 | |
| // | | |------------->| |
| // | | | SubResp1 | |
| // | | |<-------------| |
| // | | SubResp1 | | |
| // | |<-------------| | |
| // | | | | |
| // | | |
| // | submgr restart | |
| // | | |
| // | | | | |
| // | | | | |
| // | SubReq2 | | |
| // |--------------------------->| | |
| // | | | | |
| // | SubResp2 | | |
| // |<---------------------------| | |
| // | | | | |
| // | | SubDelReq 1 | | |
| // | |------------->| | |
| // | | | | |
| // | | SubDelResp 1 | | |
| // | |<-------------| | |
| // | | | | |
| // | | | | |
| // | | |
| // | submgr restart | |
| // | | |
| // | | | | |
| // | SubDelReq 2 | | |
| // |--------------------------->| | |
| // | | | | |
| // | | | SubDelReq 2 | |
| // | | |------------->| |
| // | | | | |
| // | | | SubDelReq 2 | |
| // | | |------------->| |
| // | | | | |
| // | SubDelResp 2 | | |
| // |<---------------------------| | |
| // |
| //----------------------------------------------------------------------------- |
| |
| func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) { |
| CaseBegin("TestSubReqAndSubDelOkSameActionWithRestartsInMiddle") |
| |
| //Req1 |
| rparams1 := &teststube2ap.E2StubSubsReqParams{} |
| rparams1.Init() |
| cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil) |
| crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq1, cremsg1) |
| e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1) |
| |
| //Req2 |
| rparams2 := &teststube2ap.E2StubSubsReqParams{} |
| rparams2.Init() |
| cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil) |
| e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2) |
| |
| // Check subscription |
| 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"}) |
| |
| mainCtrl.SimulateRestart(t) |
| xapp.Logger.Debug("mainCtrl.SimulateRestart done") |
| |
| // Check that subscription is restored correctly after restart |
| 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"}) |
| |
| //Del1 |
| deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1) |
| xapp.Logger.Debug("xappConn1.RecvSubsDelResp") |
| xappConn1.RecvSubsDelResp(t, deltrans1) |
| xapp.Logger.Debug("xappConn1.RecvSubsDelResp received") |
| |
| mainCtrl.SimulateRestart(t) |
| xapp.Logger.Debug("mainCtrl.SimulateRestart done") |
| |
| //Del2 |
| deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2) |
| delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t) |
| |
| e2termConn1.SendSubsDelResp(t, delreq2, delmsg2) |
| xappConn2.RecvSubsDelResp(t, deltrans2) |
| |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId2, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //***************************************************************************** |
| // REST interface test cases |
| //***************************************************************************** |
| |
| //----------------------------------------------------------------------------- |
| // Test debug GET and POST requests |
| // |
| // curl |
| // +-------+ +---------+ |
| // | user | | submgr | |
| // +-------+ +---------+ |
| // | | |
| // | GET/POST Req | |
| // |------------->| |
| // | Resp | |
| // |<-------------| |
| // | | |
| func TestGetSubscriptions(t *testing.T) { |
| |
| mainCtrl.sendGetRequest(t, "localhost:8088", "/ric/v1/subscriptions") |
| } |
| |
| func TestGetSymptomData(t *testing.T) { |
| |
| mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/symptomdata") |
| } |
| |
| func TestPostdeleteSubId(t *testing.T) { |
| |
| mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/deletesubid=1") |
| } |
| |
| 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 |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | rtmgr | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | RESTSubReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubResp | | |
| // |<----------------| | |
| // | | RouteCreate | |
| // | |------------->| |
| // | | | |
| // | | RouteCreate | |
| // | | status:400 | |
| // | |(Bad request) | |
| // | |<-------------| |
| // | RESTNotif | | |
| // |<----------------| | |
| // | | | |
| // | [SUBS INT DELETE] | |
| // | | | |
| // | RESTSubDelReq | | |
| // |---------------->| | |
| // | RESTSubDelResp | | |
| // |<----------------| | |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTSubReqAndRouteNok(t *testing.T) { |
| CaseBegin("TestRESTSubReqAndRouteNok") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 1}, |
| Counter{cRestSubRespToXapp, 1}, |
| Counter{cRouteCreateFail, 1}, |
| Counter{cRestSubFailNotifToXapp, 1}, |
| Counter{cRestSubDelReqFromXapp, 1}, |
| Counter{cRestSubDelRespToXapp, 1}, |
| }) |
| |
| const subReqCount 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) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| xappConn1.ExpectRESTNotificationNok(t, restSubId, "failAll") |
| waiter.WaitResult(t) |
| |
| e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) |
| xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId) |
| |
| // Del |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, newSubsId, 10) |
| waitSubsCleanup(t, e2SubsId, 10) |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| func TestRESTSubReqAndRouteUpdateNok(t *testing.T) { |
| CaseBegin("TestSubReqAndRouteUpdateNok") |
| |
| //Init counter check |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 2}, |
| Counter{cRestSubRespToXapp, 2}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubRespFromE2, 1}, |
| Counter{cRestSubNotifToXapp, 1}, |
| Counter{cRestSubFailNotifToXapp, 1}, |
| Counter{cRouteCreateUpdateFail, 1}, |
| Counter{cRestSubDelReqFromXapp, 1}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| Counter{cRestSubDelRespToXapp, 1}, |
| }) |
| |
| var params *teststube2ap.RESTSubsReqParams = nil |
| |
| //Subs Create |
| restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) |
| |
| queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"}) |
| |
| // 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) |
| params.SetMeid("RAN_NAME_1") |
| restSubId2 := xappConn2.SendRESTSubsReq(t, params) |
| 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) |
| |
| mainCtrl.wait_subs_clean(t, newSubsId, 10) |
| //Wait that subs is cleaned |
| waitSubsCleanup(t, e2SubsId, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) { |
| CaseBegin("TestRESTSubDelReqAndRouteDeleteNok") |
| |
| // Init counter check |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 1}, |
| Counter{cRestSubRespToXapp, 1}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubRespFromE2, 1}, |
| Counter{cRestSubNotifToXapp, 1}, |
| Counter{cRestSubDelReqFromXapp, 1}, |
| Counter{cRouteDeleteFail, 1}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| Counter{cRestSubDelRespToXapp, 1}, |
| }) |
| |
| var params *teststube2ap.RESTSubsReqParams = nil |
| |
| //Subs Create |
| restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) |
| |
| queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"}) |
| |
| waiter := rtmgrHttp.AllocNextEvent(false) |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| waiter.WaitResult(t) |
| |
| waitSubsCleanup(t, e2SubsId, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) { |
| CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 2}, |
| Counter{cRestSubRespToXapp, 2}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubRespFromE2, 1}, |
| Counter{cRestSubNotifToXapp, 2}, |
| Counter{cRestSubDelReqFromXapp, 2}, |
| Counter{cRouteDeleteUpdateFail, 1}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| Counter{cRestSubDelRespToXapp, 2}, |
| }) |
| |
| var params *teststube2ap.RESTSubsReqParams = nil |
| |
| //Subs Create |
| restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) |
| |
| queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"}) |
| restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1") |
| |
| queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"}) |
| |
| //Del1, this shall fail on rtmgr side |
| waiter := rtmgrHttp.AllocNextEvent(false) |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| waiter.WaitResult(t) |
| |
| queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"}) |
| |
| //Del2 |
| deleteXapp2Subscription(t, &restSubId2) |
| |
| waitSubsCleanup(t, e2SubsId2, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTSubReqRetransmission |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | RESTSubReq1 | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubResp | | |
| // |<----------------| | |
| // | | SubReq1 | |
| // | |------------->| |
| // | | | |
| // | RESTSubReq2 | | |
| // | (retrans) | | |
| // |---------------->| | |
| // | RESTSubResp(201)| | |
| // |<----------------| | |
| // | | | |
| // | | SubResp1 | |
| // | |<-------------| |
| // | RESTNotif1 | | |
| // |<----------------| | |
| // | | | |
| // | [SUBS DELETE] | |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| |
| func TestRESTSubReqRetransmission(t *testing.T) { |
| CaseBegin("TestRESTSubReqRetransmission") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| 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. |
| // 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 |
| |
| // 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) |
| restSubId1 := xappConn1.SendRESTSubsReq(t, params) |
| xappConn2.SendRESTSubsReq(t, params) |
| |
| waiter.WaitResult(t) |
| |
| xappConn1.WaitListedRestNotifications(t, []string{restSubId1}) |
| |
| // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus |
| // the order is not significant he6re. |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| |
| e2SubsIdA := <-xappConn1.ListedRESTNotifications |
| xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA) |
| |
| // Del1 |
| xappConn1.SendRESTSubsDelReq(t, &restSubId1) |
| delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq1, delmsg1) |
| |
| mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId}, 10) |
| |
| mainCtrl.VerifyCounterValues(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 | | | |
| // | [RETRANS1] | | | |
| // |---------------->| | | |
| // | RESTNotif1 | | | |
| // |<----------------| | | |
| // | RESTSubReq | | | |
| // | [RETRANS2] | | | |
| // |---------------->| | | |
| // | RESTNotif1 | | | |
| // |<----------------| | | |
| // | RESTSubDelReq | | | |
| // |---------------->| | | |
| // | | SubDelReq | | |
| // | |------------->| | |
| // | RESTSubDelResp| | | |
| // |<----------------| | | |
| // | | SubDelResp | | |
| // | |<-------------| | |
| // | | | | |
| // |
| //----------------------------------------------------------------------------- |
| |
| func TestRESTSubReqRetransmissionV2(t *testing.T) { |
| CaseBegin("TestRESTSubReqRetransmissionV2") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 3}, |
| 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"}) |
| |
| //1.st resend |
| restSubId_resend := xappConn1.SendRESTSubsReq(t, params) |
| |
| assert.Equal(t, restSubId_resend, restSubId) |
| |
| <-time.After(100 * time.Millisecond) |
| |
| //2.nd resend |
| restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params) |
| |
| assert.Equal(t, restSubId_resend2, restSubId) |
| |
| <-time.After(100 * time.Millisecond) |
| |
| deleteSubscription(t, xappConn1, e2termConn1, &restSubId) |
| |
| waitSubsCleanup(t, e2SubsId, 10) |
| |
| //Wait that subs is cleaned |
| mainCtrl.VerifyCounterValues(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{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"}) |
| |
| <-time.After(100 * time.Millisecond) |
| |
| //1.st resend with subscription ID |
| params.SetSubscriptionID(&restSubId) |
| restSubId_resend := xappConn1.SendRESTSubsReq(t, params) |
| |
| assert.Equal(t, restSubId_resend, restSubId) |
| |
| <-time.After(100 * time.Millisecond) |
| |
| //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) |
| |
| <-time.After(100 * time.Millisecond) |
| |
| deleteSubscription(t, xappConn1, e2termConn1, &restSubId) |
| |
| waitSubsCleanup(t, e2SubsId, 10) |
| |
| //Wait that subs is cleaned |
| mainCtrl.VerifyCounterValues(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{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) |
| |
| <-time.After(100 * time.Millisecond) |
| |
| // 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) |
| |
| <-time.After(100 * time.Millisecond) |
| |
| 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) |
| |
| // Delete both e2 subscriptions |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| e2SubsIds := []uint32{e2SubsId, e2SubsId2} |
| sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1) |
| |
| waitSubsCleanup(t, e2SubsId, 10) |
| |
| //Wait that subs is cleaned |
| mainCtrl.VerifyCounterValues(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{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) |
| |
| <-time.After(100 * time.Millisecond) |
| |
| // 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) |
| // 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) |
| |
| <-time.After(100 * time.Millisecond) |
| |
| 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) |
| |
| // Delete both e2 subscriptions |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| e2SubsIds := []uint32{e2SubsId, e2SubsId2} |
| sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1) |
| |
| waitSubsCleanup(t, e2SubsId, 10) |
| |
| //Wait that subs is cleaned |
| mainCtrl.VerifyCounterValues(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{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) |
| |
| <-time.After(100 * time.Millisecond) |
| |
| // 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) |
| |
| <-time.After(100 * time.Millisecond) |
| |
| // 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) |
| |
| <-time.After(100 * time.Millisecond) |
| |
| deleteSubscription(t, xappConn1, e2termConn1, &restSubId) |
| |
| waitSubsCleanup(t, e2SubsId, 10) |
| |
| //Wait that subs is cleaned |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| func TestRESTSubDelReqRetransmission(t *testing.T) { |
| CaseBegin("TestRESTSubDelReqRetransmission") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 1}, |
| Counter{cRestSubRespToXapp, 1}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubRespFromE2, 1}, |
| Counter{cRestSubNotifToXapp, 1}, |
| Counter{cRestSubDelReqFromXapp, 2}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| Counter{cRestSubDelRespToXapp, 1}, |
| }) |
| |
| var params *teststube2ap.RESTSubsReqParams = nil |
| |
| //Subs Create |
| restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) |
| |
| queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"}) |
| |
| //Subs Delete |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| |
| seqBef := mainCtrl.get_msgcounter(t) |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| mainCtrl.wait_msgcounter_change(t, seqBef, 10) |
| |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| |
| waitSubsCleanup(t, e2SubsId, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTSubReqDelReq |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | RESTSubReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubResp | | |
| // |<----------------| | |
| // | | SubReq | |
| // | |------------->| |
| // | RESTSubDelReq | | |
| // |---------------->| | |
| // | RESTSubDelResp | | |
| // | unsuccess | | |
| // |<----------------| | |
| // | | SubResp | |
| // | |<-------------| |
| // | RESTNotif1 | | |
| // |<----------------| | |
| // | | | |
| // | [SUBS DELETE] | |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTSubReqDelReq(t *testing.T) { |
| CaseBegin("TestRESTSubReqDelReq") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 1}, |
| Counter{cRestSubRespToXapp, 1}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubRespFromE2, 1}, |
| Counter{cRestSubNotifToXapp, 1}, |
| Counter{cRestSubDelReqFromXapp, 2}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| Counter{cRestSubDelRespToXapp, 1}, |
| }) |
| |
| const subReqCount int = 1 |
| |
| // Req |
| params := xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| |
| // Del. This will fail as processing of the subscription |
| // is still ongoing in submgr. Deletion is not allowed before |
| // subscription creation has been completed. |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| xappConn1.ExpectRESTNotification(t, restSubId) |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) |
| |
| // Retry 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) |
| |
| } |
| |
| func TestRESTSubDelReqCollision(t *testing.T) { |
| CaseBegin("TestRESTSubDelReqCollision - not relevant for REST API") |
| } |
| |
| func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) { |
| CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 2}, |
| Counter{cRestSubRespToXapp, 2}, |
| Counter{cSubReqToE2, 2}, |
| Counter{cSubRespFromE2, 2}, |
| Counter{cRestSubNotifToXapp, 2}, |
| Counter{cRestSubDelReqFromXapp, 2}, |
| Counter{cSubDelReqToE2, 2}, |
| Counter{cSubDelRespFromE2, 2}, |
| Counter{cRestSubDelRespToXapp, 2}, |
| }) |
| |
| //Req1 |
| params := xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| restSubId1 := xappConn1.SendRESTSubsReq(t, params) |
| xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1) |
| |
| //Req2 |
| params = xappConn2.GetRESTSubsReqReportParams(subReqCount) |
| restSubId2 := xappConn2.SendRESTSubsReq(t, params) |
| xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2) |
| |
| crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) |
| crereq2, cremsg2 := e2termConn1.RecvSubsReq(t) |
| |
| //XappConn1 receives both of the responses |
| xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2}) |
| |
| //Resp1 |
| e2termConn1.SendSubsResp(t, crereq1, cremsg1) |
| //Resp2 |
| e2termConn1.SendSubsResp(t, crereq2, cremsg2) |
| |
| e2SubsIdA := <-xappConn1.ListedRESTNotifications |
| xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA) |
| e2SubsIdB := <-xappConn1.ListedRESTNotifications |
| xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB) |
| |
| //Del1 |
| deleteSubscription(t, xappConn1, e2termConn1, &restSubId1) |
| //Del2 |
| deleteSubscription(t, xappConn2, e2termConn1, &restSubId2) |
| |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10) |
| waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| |
| } |
| |
| func TestRESTSameSubsDiffRan(t *testing.T) { |
| CaseBegin("TestRESTSameSubsDiffRan") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 2}, |
| Counter{cRestSubRespToXapp, 2}, |
| Counter{cSubReqToE2, 2}, |
| Counter{cSubRespFromE2, 2}, |
| Counter{cRestSubNotifToXapp, 2}, |
| Counter{cRestSubDelReqFromXapp, 2}, |
| Counter{cSubDelReqToE2, 2}, |
| Counter{cSubDelRespFromE2, 2}, |
| Counter{cRestSubDelRespToXapp, 2}, |
| }) |
| |
| params := xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) |
| xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1) |
| |
| params = xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| params.SetMeid("RAN_NAME_2") |
| restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params) |
| xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2) |
| |
| //Del1 |
| deleteSubscription(t, xappConn1, e2termConn1, &restSubId1) |
| //Del2 |
| deleteSubscription(t, xappConn1, e2termConn1, &restSubId2) |
| |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId1, 10) |
| waitSubsCleanup(t, e2SubsId2, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| |
| } |
| |
| func TestRESTSubReqRetryInSubmgr(t *testing.T) { |
| CaseBegin("TestRESTSubReqRetryInSubmgr start") |
| |
| // Init counter check |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 1}, |
| Counter{cRestSubRespToXapp, 1}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubReReqToE2, 1}, |
| Counter{cSubRespFromE2, 1}, |
| Counter{cRestSubNotifToXapp, 1}, |
| Counter{cRestSubDelReqFromXapp, 1}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| Counter{cRestSubDelRespToXapp, 1}, |
| }) |
| |
| params := xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| |
| 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.Debug("Ignore REST subscriber request for subscriber : %v", restSubId) |
| |
| // The second request is being handled normally |
| crereq, cremsg = e2termConn1.RecvSubsReq(t) |
| xappConn1.ExpectRESTNotification(t, restSubId) |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) |
| |
| queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"}) |
| |
| deleteSubscription(t, xappConn1, e2termConn1, &restSubId) |
| |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| //Wait that subs is cleaned |
| waitSubsCleanup(t, e2SubsId, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | RESTSubReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubResp | | |
| // |<----------------| | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | RESTNotif | | |
| // | unsuccess | | |
| // |<----------------| | |
| // | | | |
| // | [SUBS DELETE] | |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| |
| func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) { |
| CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start") |
| |
| // Init counter check |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 1}, |
| Counter{cRestSubRespToXapp, 1}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubReReqToE2, 1}, |
| Counter{cSubReqTimerExpiry, 2}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| }) |
| |
| params := xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId) |
| |
| e2termConn1.RecvSubsReq(t) |
| xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId) |
| |
| e2termConn1.RecvSubsReq(t) |
| xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId) |
| |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| xappConn1.WaitRESTNotification(t, restSubId) |
| |
| // Wait that subs is cleaned |
| waitSubsCleanup(t, delreq.RequestId.InstanceId, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| func TestREST2eTermNotRespondingToSubReq(t *testing.T) { |
| CaseBegin("TestREST2eTermNotRespondingToSubReq start") |
| |
| // Init counter check |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 1}, |
| Counter{cRestSubRespToXapp, 1}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubReReqToE2, 1}, |
| Counter{cSubReqTimerExpiry, 2}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelReqTimerExpiry, 2}, |
| }) |
| |
| params := xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId) |
| |
| e2termConn1.RecvSubsReq(t) |
| xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId) |
| |
| e2termConn1.RecvSubsReq(t) |
| xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId) |
| |
| e2termConn1.RecvSubsDelReq(t) |
| xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId) |
| |
| xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") |
| e2termConn1.RecvSubsDelReq(t) |
| xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId) |
| |
| e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) |
| |
| waitSubsCleanup(t, e2SubsId, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | RESTSubReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubResp | | |
| // |<----------------| | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | RESTNotif | | |
| // | unsuccess | | |
| // |<----------------| | |
| // | | | |
| // | [SUBS DELETE] | |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) { |
| CaseBegin("TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr start") |
| |
| // Init counter check |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 1}, |
| Counter{cRestSubRespToXapp, 1}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubReReqToE2, 1}, |
| Counter{cSubReqTimerExpiry, 2}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelReReqToE2, 1}, |
| Counter{cSubDelReqTimerExpiry, 2}, |
| }) |
| |
| params := xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId) |
| |
| e2termConn1.RecvSubsReq(t) |
| xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId) |
| |
| e2termConn1.RecvSubsReq(t) |
| xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId) |
| |
| e2termConn1.RecvSubsDelReq(t) |
| xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId) |
| |
| xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") |
| e2termConn1.RecvSubsDelReq(t) |
| xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId) |
| |
| e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) |
| |
| waitSubsCleanup(t, e2SubsId, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTSubReqSubFailRespInSubmgr |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | RESTSubReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubResp | | |
| // |<----------------| | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubFail | |
| // | |<-------------| |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | | | |
| // | RESTNotif | | |
| // | unsuccess | | |
| // |<----------------| | |
| // | | | |
| // | [SUBS DELETE] | |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) { |
| CaseBegin("TestRESTSubReqSubFailRespInSubmgr") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 1}, |
| Counter{cRestSubRespToXapp, 1}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubFailFromE2, 1}, |
| Counter{cRestSubFailNotifToXapp, 1}, |
| Counter{cRestSubDelReqFromXapp, 1}, |
| }) |
| |
| const subReqCount int = 1 |
| const e2Timeout int64 = 2 |
| const e2RetryCount int64 = 1 |
| const routingNeeded bool = true |
| |
| 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) |
| e2termConn1.SendSubsFail(t, fparams1, cremsg1) |
| |
| delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t) |
| xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") |
| e2termConn1.SendSubsDelResp(t, delreq1, delmsg1) |
| e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) |
| xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId) |
| |
| // REST subscription sill there to be deleted |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| |
| // Wait that subs is cleaned |
| waitSubsCleanup(t, e2SubsId, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTSubDelReqRetryInSubmgr |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | [SUBS CREATE] | |
| // | | | |
| // | | | |
| // | RESTSubDelReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubDelResp | | |
| // |<----------------| | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTSubDelReqRetryInSubmgr(t *testing.T) { |
| CaseBegin("TestRESTSubDelReqRetryInSubmgr") |
| |
| 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{cSubDelReReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| Counter{cRestSubDelRespToXapp, 1}, |
| }) |
| // Req |
| var params *teststube2ap.RESTSubsReqParams = nil |
| restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) |
| |
| // Del |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| |
| // E2t: Receive 1st SubsDelReq |
| e2termConn1.RecvSubsDelReq(t) |
| |
| // E2t: Receive 2nd SubsDelReq and send SubsDelResp |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| |
| //Wait that subs is cleaned |
| waitSubsCleanup(t, e2SubsId, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTSubDelReqTwoRetriesNoRespInSubmgr |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | [SUBS CREATE] | |
| // | | | |
| // | | | |
| // | RESTSubDelReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubDelResp | | |
| // |<----------------| | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) { |
| CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr") |
| |
| 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{cSubDelReReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| Counter{cRestSubDelRespToXapp, 1}, |
| }) |
| |
| // Req |
| var params *teststube2ap.RESTSubsReqParams = nil |
| restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) |
| |
| // Del |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| |
| // E2t: Receive 1st SubsDelReq |
| e2termConn1.RecvSubsDelReq(t) |
| |
| // E2t: Receive 2nd SubsDelReq and send SubsDelResp |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| |
| //Wait that subs is cleaned |
| waitSubsCleanup(t, e2SubsId, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTSubDelReqSubDelFailRespInSubmgr |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | [SUBS CREATE] | |
| // | | | |
| // | | | |
| // | RESTSubDelReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubDelResp | | |
| // |<----------------| | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelFail | |
| // | |<-------------| |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) { |
| CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr") |
| |
| 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{cSubDelFailFromE2, 1}, |
| Counter{cRestSubDelRespToXapp, 1}, |
| }) |
| |
| // Req |
| var params *teststube2ap.RESTSubsReqParams = nil |
| restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) |
| |
| // Del |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| |
| // E2t: Send receive SubsDelReq and send SubsDelFail |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelFail(t, delreq, delmsg) |
| |
| //Wait that subs is cleaned |
| waitSubsCleanup(t, e2SubsId, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTSubReqAndSubDelOkSameAction |
| // |
| // stub stub |
| // +-------+ +-------+ +---------+ +---------+ |
| // | xapp2 | | xapp1 | | submgr | | e2term | |
| // +-------+ +-------+ +---------+ +---------+ |
| // | | | | |
| // | | RESTSubReq1 | | |
| // | |---------------->| | |
| // | | | | |
| // | | RESTSubResp1 | | |
| // | |<----------------| | |
| // | | | | |
| // | | | SubReq1 | |
| // | | |------------->| |
| // | | | SubResp1 | |
| // | | |<-------------| |
| // | | RESTNotif1 | | |
| // | |<----------------| | |
| // | | | | |
| // | RESTSubReq2 | | |
| // |------------------------------>| | |
| // | | | | |
| // | RESTSubResp2 | | |
| // |<------------------------------| | |
| // | | | | |
| // | | RESTNotif2 | | |
| // |<------------------------------| | |
| // | | | | |
| // | | RESTSubDelReq1 | | |
| // | |---------------->| | |
| // | | | | |
| // | | RESTSubDelResp1 | | |
| // | |<----------------| | |
| // | | | | |
| // | RESTSubDelReq2 | | |
| // |------------------------------>| | |
| // | | | | |
| // | RESTSubDelResp2 | | |
| // |<------------------------------| | |
| // | | | | |
| // | | | SubDelReq2 | |
| // | | |------------->| |
| // | | | | |
| // | | | SubDelResp2 | |
| // | | |<-------------| |
| // | | | | |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) { |
| CaseBegin("TestRESTSubReqAndSubDelOkSameAction") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 2}, |
| Counter{cRestSubRespToXapp, 2}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubRespFromE2, 1}, |
| Counter{cRestSubNotifToXapp, 2}, |
| Counter{cMergedSubscriptions, 1}, |
| Counter{cUnmergedSubscriptions, 1}, |
| Counter{cRestSubDelReqFromXapp, 2}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| Counter{cRestSubDelRespToXapp, 2}, |
| }) |
| |
| // Req1 |
| var params *teststube2ap.RESTSubsReqParams = nil |
| |
| //Subs Create |
| restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) |
| queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"}) |
| |
| // Req2 |
| params = xappConn2.GetRESTSubsReqReportParams(subReqCount) |
| params.SetMeid("RAN_NAME_1") |
| |
| xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler) |
| xappConn2.ExpectAnyNotification(t) |
| waiter := rtmgrHttp.AllocNextSleep(10, true) |
| restSubId2 := xappConn2.SendRESTSubsReq(t, params) |
| waiter.WaitResult(t) |
| 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"}) |
| |
| // Del1 |
| xappConn1.SendRESTSubsDelReq(t, &restSubId1) |
| |
| // Del2 |
| deleteXapp2Subscription(t, &restSubId2) |
| |
| //Wait that subs is cleaned |
| waitSubsCleanup(t, e2SubsId2, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqAndSubDelOkSameActionParallel |
| // |
| // stub stub stub |
| // +-------+ +-------+ +---------+ +---------+ |
| // | xapp2 | | xapp1 | | submgr | | e2term | |
| // +-------+ +-------+ +---------+ +---------+ |
| // | | | | |
| // | | | | |
| // | | | | |
| // | | SubReq1 | | |
| // | |------------->| | |
| // | | | | |
| // | | | SubReq1 | |
| // | | |------------->| |
| // | SubReq2 | | |
| // |--------------------------->| | |
| // | | | SubResp1 | |
| // | | |<-------------| |
| // | | SubResp1 | | |
| // | |<-------------| | |
| // | | | SubReq2 | |
| // | | |------------->| |
| // | | | | |
| // | | | SubResp2 | |
| // | | |<-------------| |
| // | SubResp2 | | |
| // |<---------------------------| | |
| // | | | | |
| // | | SubDelReq 1 | | |
| // | |------------->| | |
| // | | | | |
| // | | SubDelResp 1 | | |
| // | |<-------------| | |
| // | | | | |
| // | SubDelReq 2 | | |
| // |--------------------------->| | |
| // | | | | |
| // | | | SubDelReq 2 | |
| // | | |------------->| |
| // | | | | |
| // | | | SubDelReq 2 | |
| // | | |------------->| |
| // | | | | |
| // | SubDelResp 2 | | |
| // |<---------------------------| | |
| // |
| func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) { |
| CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 2}, |
| Counter{cRestSubRespToXapp, 2}, |
| Counter{cSubReqToE2, 2}, |
| Counter{cSubRespFromE2, 2}, |
| Counter{cRestSubNotifToXapp, 2}, |
| Counter{cRestSubDelReqFromXapp, 2}, |
| Counter{cSubDelReqToE2, 2}, |
| Counter{cSubDelRespFromE2, 2}, |
| Counter{cRestSubDelRespToXapp, 2}, |
| }) |
| |
| params := xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| restSubId1 := xappConn1.SendRESTSubsReq(t, params) |
| crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) |
| |
| params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount) |
| restSubId2 := xappConn2.SendRESTSubsReq(t, params2) |
| |
| xappConn1.ExpectRESTNotification(t, restSubId1) |
| e2termConn1.SendSubsResp(t, crereq1, cremsg1) |
| e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1) |
| |
| xappConn2.ExpectRESTNotification(t, restSubId2) |
| crereq2, cremsg2 := e2termConn1.RecvSubsReq(t) |
| e2termConn1.SendSubsResp(t, crereq2, cremsg2) |
| e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) |
| |
| // Del1 |
| xappConn1.SendRESTSubsDelReq(t, &restSubId1) |
| delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq1, delmsg1) |
| mainCtrl.wait_subs_clean(t, e2SubsId1, 10) |
| |
| // Del2 |
| xappConn2.SendRESTSubsDelReq(t, &restSubId2) |
| delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq2, delmsg2) |
| |
| waitSubsCleanup(t, e2SubsId2, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTSubReqAndSubDelNoAnswerSameActionParallel |
| // |
| // stub stub stub |
| // +-------+ +-------+ +---------+ +---------+ |
| // | xapp2 | | xapp1 | | submgr | | e2term | |
| // +-------+ +-------+ +---------+ +---------+ |
| // | | | | |
| // | | | | |
| // | | | | |
| // | | RESTSubReq1 | | |
| // | |---------------->| | |
| // | | | | |
| // | | RESTSubResp1 | | |
| // | |<----------------| | |
| // | | | SubReq1 | |
| // | | |------------->| |
| // | RESTSubReq2 | | |
| // |------------------------------>| | |
| // | | | | |
| // | RESTSubDelResp2 | | |
| // |<------------------------------| | |
| // | | | SubReq1 | |
| // | | |------------->| |
| // | | | | |
| // | | | | |
| // | | | SubDelReq | |
| // | | |------------->| |
| // | | | | |
| // | | | SubDelResp | |
| // | | |<-------------| |
| // | | RESTNotif1 | | |
| // | | unsuccess | | |
| // | |<----------------| | |
| // | RESTNotif2 | | |
| // | | unsuccess | | |
| // |<------------------------------| | |
| // | | | | |
| // | | RESTSubDelReq1 | | |
| // | |---------------->| | |
| // | | | | |
| // | | RESTSubDelResp1 | | |
| // | |<----------------| | |
| // | | | | |
| // | RESTSubDelReq2 | | |
| // |------------------------------>| | |
| // | | | | |
| // | RESTSubDelResp2 | | |
| // |<------------------------------| | |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) { |
| CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 2}, |
| Counter{cRestSubRespToXapp, 2}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cRestSubFailNotifToXapp, 2}, |
| Counter{cRestSubDelReqFromXapp, 2}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| Counter{cRestSubDelRespToXapp, 2}, |
| }) |
| |
| const subReqCount int = 1 |
| |
| // Req1 |
| 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) |
| params2.SetMeid("RAN_NAME_1") |
| restSubId2 := xappConn2.SendRESTSubsReq(t, params2) |
| mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10) |
| |
| //Req1 (retransmitted) |
| e2termConn1.RecvSubsReq(t) |
| |
| delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t) |
| |
| xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2}) |
| e2termConn1.SendSubsDelResp(t, delreq1, delmsg1) |
| |
| e2SubsIdA := <-xappConn1.ListedRESTNotifications |
| xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA) |
| e2SubsIdB := <-xappConn1.ListedRESTNotifications |
| xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB) |
| |
| // Del1 |
| xappConn1.SendRESTSubsDelReq(t, &restSubId1) |
| |
| // Del2 |
| xappConn2.SendRESTSubsDelReq(t, &restSubId2) |
| |
| mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10) |
| |
| //Wait that subs is cleaned |
| waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTSubReqAndSubDelNokSameActionParallel |
| // |
| // stub stub stub |
| // +-------+ +-------+ +---------+ +---------+ |
| // | xapp2 | | xapp1 | | submgr | | e2term | |
| // +-------+ +-------+ +---------+ +---------+ |
| // | | | | |
| // | | | | |
| // | | | | |
| // | | RESTSubReq1 | | |
| // | |---------------->| | |
| // | | | | |
| // | | RESTSubResp1 | | |
| // | |<----------------| | |
| // | | | SubReq1 | |
| // | | |------------->| |
| // | RESTSubReq2 | | |
| // |------------------------------>| | |
| // | | | | |
| // | RESTSubDelResp2 | | |
| // |<------------------------------| | |
| // | | | SubFail1 | |
| // | | |<-------------| |
| // | | | | |
| // | | RESTNotif1 | | |
| // | | unsuccess | | |
| // | |<----------------| | |
| // | RESTNotif2 | | |
| // | | unsuccess | | |
| // |<------------------------------| | |
| // | | | SubDelReq | |
| // | | |------------->| |
| // | | | SubDelResp | |
| // | | |<-------------| |
| // | | | | |
| // | | RESTSubDelReq1 | | |
| // | |---------------->| | |
| // | | | | |
| // | | RESTSubDelResp1 | | |
| // | |<----------------| | |
| // | | | | |
| // | RESTSubDelReq2 | | |
| // |------------------------------>| | |
| // | | | | |
| // | RESTSubDelResp2 | | |
| // |<------------------------------| | |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) { |
| CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 2}, |
| Counter{cRestSubRespToXapp, 2}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubFailFromE2, 1}, |
| Counter{cRestSubFailNotifToXapp, 2}, |
| Counter{cRestSubDelReqFromXapp, 2}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| Counter{cRestSubDelRespToXapp, 2}, |
| }) |
| |
| const subReqCount int = 1 |
| |
| // Req1 |
| 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) |
| params2.SetMeid("RAN_NAME_1") |
| restSubId2 := xappConn2.SendRESTSubsReq(t, params2) |
| mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10) |
| |
| // E2t: send SubsFail (first) |
| fparams1 := &teststube2ap.E2StubSubsFailParams{} |
| 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.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA) |
| e2SubsIdB := <-xappConn1.ListedRESTNotifications |
| xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB) |
| |
| // Del1 |
| xappConn1.SendRESTSubsDelReq(t, &restSubId1) |
| |
| // Del2 |
| xappConn2.SendRESTSubsDelReq(t, &restSubId2) |
| |
| //Wait that subs is cleaned |
| waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10) |
| waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) { |
| CaseBegin("TestRESTSubReqPolicyAndSubDelOk") |
| |
| // Init counter check |
| 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}, |
| }) |
| |
| params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| 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.Debug("REST notification received e2SubsId=%v", e2SubsId) |
| |
| 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) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTSubReqPolicyChangeAndSubDelOk |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | RESTSubReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubResp | | |
| // |<----------------| | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubResp | |
| // | |<-------------| |
| // | | | |
| // | RESTNotif | | |
| // |<----------------| | |
| // | | | |
| // | RESTSubReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubResp | | |
| // |<----------------| | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubResp | |
| // | |<-------------| |
| // | | | |
| // | RESTNotif | | |
| // |<----------------| | |
| // | | | |
| // | RESTSubDelReq | | |
| // |---------------->| | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | | | |
| // | RESTSubDelResp | | |
| // |<----------------| | |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) { |
| CaseBegin("TestRESTSubReqPolicyAndSubDelOk") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 2}, |
| Counter{cRestSubRespToXapp, 2}, |
| Counter{cSubReqToE2, 2}, |
| Counter{cSubRespFromE2, 2}, |
| Counter{cRestSubNotifToXapp, 2}, |
| Counter{cRestSubDelReqFromXapp, 1}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| Counter{cRestSubDelRespToXapp, 1}, |
| }) |
| |
| const subReqCount int = 1 |
| const e2Timeout int64 = 1 |
| const e2RetryCount int64 = 0 |
| const routingNeeded bool = true |
| |
| // Req |
| params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) |
| params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded) |
| restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) |
| |
| // Policy change |
| // 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) |
| |
| // 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) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // 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) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTSubReqAndSubDelOkTwoE2termParallel |
| // |
| // stub stub stub |
| // +-------+ +---------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term1 | | e2term2 | |
| // +-------+ +---------+ +---------+ +---------+ |
| // | | | | |
| // | | | | |
| // | | | | |
| // | RESTSubReq1 | | | |
| // |---------------->| | | |
| // | | | | |
| // | RESTSubResp1 | | | |
| // |<----------------| | | |
| // | | SubReq1 | | |
| // | |------------->| | |
| // | | | | |
| // | RESTSubReq2 | | | |
| // |---------------->| | | |
| // | | | | |
| // | RESTSubResp2 | | | |
| // |<----------------| | | |
| // | | SubReq2 | | |
| // | |---------------------------->| |
| // | | | | |
| // | | SubResp1 | | |
| // | |<-------------| | |
| // | RESTNotif1 | | | |
| // |<----------------| | | |
| // | | SubResp2 | | |
| // | |<----------------------------| |
| // | RESTNotif2 | | | |
| // |<----------------| | | |
| // | | | | |
| // | [SUBS 1 DELETE] | | |
| // | | | | |
| // | [SUBS 2 DELETE] | | |
| // | | | | |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) { |
| CaseBegin("TestRESTSubReqAndSubDelOkTwoE2termParallel") |
| |
| // Init counter check |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 2}, |
| Counter{cRestSubRespToXapp, 2}, |
| Counter{cSubReqToE2, 2}, |
| Counter{cSubRespFromE2, 2}, |
| Counter{cRestSubNotifToXapp, 2}, |
| Counter{cRestSubDelReqFromXapp, 2}, |
| Counter{cSubDelReqToE2, 2}, |
| Counter{cSubDelRespFromE2, 2}, |
| Counter{cRestSubDelRespToXapp, 2}, |
| }) |
| |
| const subReqCount int = 1 |
| |
| // Req1 |
| params := xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| restSubId1 := xappConn1.SendRESTSubsReq(t, params) |
| crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) |
| |
| // Req2 |
| 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 |
| restSubId2 := xappConn2.SendRESTSubsReq(t, params) |
| crereq2, cremsg2 := e2termConn2.RecvSubsReq(t) |
| |
| // Resp1 |
| xappConn1.ExpectRESTNotification(t, restSubId1) |
| e2termConn1.SendSubsResp(t, crereq1, cremsg1) |
| e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1) |
| 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.Debug("TEST: REST notification received e2SubsId2=%v", e2SubsId2) |
| |
| // Delete1 |
| xappConn1.SendRESTSubsDelReq(t, &restSubId1) |
| delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq1, delmsg1) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId1, 10) |
| |
| // Delete2 |
| xappConn1.SendRESTSubsDelReq(t, &restSubId2) |
| delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t) |
| e2termConn2.SendSubsDelResp(t, delreq2, delmsg2) |
| |
| // Wait that subs is cleaned |
| waitSubsCleanup(t, e2SubsId2, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTSubReqAsn1EncodeFail |
| // |
| // In this case submgr send RICSubscriptionDeleteRequest after encode failure which should not happen! |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | RESTSubReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubResp | | |
| // |<----------------| | |
| // | RESTSubDelReq | | |
| // |---------------->| | |
| // | RESTSubDelResp | | |
| // | unsuccess | | |
| // |<----------------| | |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTSubReqAsn1EncodeFail(t *testing.T) { |
| CaseBegin("TestRESTSubReqAsn1EncodeFail") |
| |
| xapp.Logger.Debug("Xapp-frame, v0.8.1 sufficient REST API validation") |
| |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTSubReqInsertAndSubDelOk |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | RestSubReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubResp | | |
| // |<----------------| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubResp | |
| // | |<-------------| |
| // | RESTNotif | | |
| // |<----------------| | |
| // | ... | ... | |
| // | | | |
| // | RESTSubDelReq | | |
| // |---------------->| | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | | | |
| // | RESTSubDelResp| | |
| // |<----------------| | |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTSubReqInsertAndSubDelOk(t *testing.T) { |
| CaseBegin("TestRESTInsertSubReqAndSubDelOk") |
| |
| 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}, |
| }) |
| |
| const subReqCount int = 1 |
| |
| params := xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| params.SetSubActionTypes("insert") |
| |
| // Req |
| restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) |
| |
| // 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) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | RESTSubReq | | |
| // |------------->| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubResp | |
| // | <----| |
| // | | |
| // | Submgr restart | |
| // | | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) { |
| CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 1}, |
| Counter{cRestSubRespToXapp, 1}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubDelReqFromXapp, 1}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| }) |
| |
| const subReqCount int = 1 |
| |
| // Remove possible existing subscription |
| mainCtrl.removeExistingSubscriptions(t) |
| |
| 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.Debug("Send REST subscriber request for subscriber : %v", restSubId) |
| |
| e2termConn1.RecvSubsReq(t) |
| |
| mainCtrl.SetResetTestFlag(t, false) |
| |
| mainCtrl.SimulateRestart(t) |
| xapp.Logger.Debug("mainCtrl.SimulateRestart done") |
| |
| //Del |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTSubReqAndSubDelOkWithRestartInMiddle |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | RESTSubReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubResp | | |
| // |<----------------| | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubResp | |
| // | |<-------------| |
| // | | | |
| // | RESTNotif | | |
| // |<----------------| | |
| // | | | |
| // | | |
| // | Submgr restart | |
| // | | | |
| // | RESTSubDelReq | | |
| // |---------------->| | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | | | |
| // | RESTSubDelResp | | |
| // |<----------------| | |
| // |
| //----------------------------------------------------------------------------- |
| |
| func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) { |
| CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle") |
| |
| 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{cRestSubDelRespToXapp, 1}, |
| }) |
| |
| // Remove possible existing subscription |
| mainCtrl.removeExistingSubscriptions(t) |
| |
| var params *teststube2ap.RESTSubsReqParams = nil |
| |
| // Create subscription |
| restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) |
| xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId) |
| |
| // Check subscription |
| queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"}) |
| |
| mainCtrl.SimulateRestart(t) |
| xapp.Logger.Debug("mainCtrl.SimulateRestart done") |
| |
| // Check subscription |
| queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"}) |
| |
| // Delete subscription |
| deleteSubscription(t, xappConn1, e2termConn1, &restSubId) |
| |
| //Wait that subs is cleaned |
| waitSubsCleanup(t, e2SubsId, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle |
| // |
| // stub stub |
| // +-------+ +-------+ +---------+ +---------+ |
| // | xapp2 | | xapp1 | | submgr | | e2term | |
| // +-------+ +-------+ +---------+ +---------+ |
| // | | | | |
| // | | RESTSubReq1 | | |
| // | |---------------->| | |
| // | | | | |
| // | | RESTSubResp1 | | |
| // | |<----------------| | |
| // | | | | |
| // | | | SubReq1 | |
| // | | |------------->| |
| // | | | SubResp1 | |
| // | | |<-------------| |
| // | | RESTNotif1 | | |
| // | |<----------------| | |
| // | | | | |
| // | RESTSubReq2 | | |
| // |------------------------------>| | |
| // | | | | |
| // | RESTSubResp2 | | |
| // |<------------------------------| | |
| // | | | | |
| // | | RESTNotif2 | | |
| // |<------------------------------| | |
| // | | | | |
| // | | Submgr restart | |
| // | | | | |
| // | | RESTSubDelReq1 | | |
| // | |---------------->| | |
| // | | | | |
| // | | RESTSubDelResp1 | | |
| // | |<----------------| | |
| // | | | | |
| // | | Submgr restart | |
| // | | | | |
| // | RESTSubDelReq2 | | |
| // |------------------------------>| | |
| // | | | | |
| // | RESTSubDelResp2 | | |
| // |<------------------------------| | |
| // | | | | |
| // | | | SubDelReq2 | |
| // | | |------------->| |
| // | | | | |
| // | | | SubDelResp2 | |
| // | | |<-------------| |
| // | | | | |
| // |
| //----------------------------------------------------------------------------- |
| |
| func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) { |
| CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 2}, |
| Counter{cRestSubRespToXapp, 2}, |
| Counter{cSubReqToE2, 1}, |
| Counter{cSubRespFromE2, 1}, |
| Counter{cRestSubNotifToXapp, 2}, |
| Counter{cMergedSubscriptions, 1}, |
| Counter{cUnmergedSubscriptions, 1}, |
| Counter{cRestSubDelReqFromXapp, 2}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cSubDelRespFromE2, 1}, |
| Counter{cRestSubDelRespToXapp, 2}, |
| }) |
| |
| // Remove possible existing subscription |
| mainCtrl.removeExistingSubscriptions(t) |
| |
| var params *teststube2ap.RESTSubsReqParams = nil |
| |
| // Create subscription 1 |
| restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) |
| xapp.Logger.Debug("Send REST subscriber request for subscriber 1 : %v", restSubId1) |
| |
| // Create subscription 2 with same action |
| params = xappConn2.GetRESTSubsReqReportParams(subReqCount) |
| params.SetMeid("RAN_NAME_1") |
| xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler) |
| xappConn2.ExpectAnyNotification(t) |
| restSubId2 := xappConn2.SendRESTSubsReq(t, params) |
| 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"}) |
| |
| mainCtrl.SimulateRestart(t) |
| xapp.Logger.Debug("mainCtrl.SimulateRestart done") |
| |
| // 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.SimulateRestart(t) |
| xapp.Logger.Debug("mainCtrl.SimulateRestart done") |
| queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"}) |
| |
| // Delete subscription 2 |
| deleteXapp2Subscription(t, &restSubId2) |
| |
| //Wait that subs is cleaned |
| waitSubsCleanup(t, e2SubsId2, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTReportSubReqAndSubDelOk |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | RestSubReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubResp | | |
| // |<----------------| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubResp | |
| // | |<-------------| |
| // | RESTNotif | | |
| // |<----------------| | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubResp | |
| // | |<-------------| |
| // | RESTNotif | | |
| // |<----------------| | |
| // | ... | ... | |
| // | | | |
| // | | | |
| // | RESTSubDelReq | | |
| // |---------------->| | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | | | |
| // | RESTSubDelResp| | |
| // |<----------------| | |
| // |
| //----------------------------------------------------------------------------- |
| |
| func TestRESTReportSubReqAndSubDelOk(t *testing.T) { |
| CaseBegin("TestRESTReportSubReqAndSubDelOk") |
| const subReqCount int = 1 |
| testIndex := 1 |
| RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex) |
| } |
| |
| func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) { |
| xapp.Logger.Debug("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex) |
| |
| // Req |
| params := xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| |
| var e2SubsId []uint32 |
| for i := 0; i < subReqCount; i++ { |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| xappConn1.ExpectRESTNotification(t, restSubId) |
| |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| instanceId := xappConn1.WaitRESTNotification(t, restSubId) |
| 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)) |
| assert.Equal(t, resp[i].Meid, "RAN_NAME_1") |
| assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"}) |
| |
| } |
| |
| // Del |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| |
| for i := 0; i < subReqCount; i++ { |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| } |
| |
| // Wait that subs is cleaned |
| for i := 0; i < subReqCount; i++ { |
| mainCtrl.wait_subs_clean(t, e2SubsId[i], 10) |
| } |
| |
| xappConn1.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| /* |
| func TestRESTPolicySubReqAndSubDelOk(t *testing.T) { |
| CaseBegin("TestRESTPolicySubReqAndSubDelOk") |
| |
| subReqCount := 2 |
| testIndex := 1 |
| RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex) |
| |
| subReqCount = 19 |
| testIndex = 2 |
| RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex) |
| } |
| */ |
| func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) { |
| xapp.Logger.Debug("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex) |
| |
| // Req |
| params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| |
| var e2SubsId []uint32 |
| for i := 0; i < subReqCount; i++ { |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| xappConn1.ExpectRESTNotification(t, restSubId) |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| instanceId := xappConn1.WaitRESTNotification(t, restSubId) |
| xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId) |
| e2SubsId = append(e2SubsId, instanceId) |
| } |
| |
| // Del |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| |
| for i := 0; i < subReqCount; i++ { |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| } |
| |
| // Wait that subs is cleaned |
| for i := 0; i < subReqCount; i++ { |
| mainCtrl.wait_subs_clean(t, e2SubsId[i], 10) |
| } |
| xappConn1.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) { |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 1}, |
| Counter{cRestSubRespToXapp, 1}, |
| Counter{cSubReqToE2, 2}, |
| Counter{cSubRespFromE2, 2}, |
| Counter{cRestSubNotifToXapp, 2}, |
| Counter{cRestSubDelReqFromXapp, 1}, |
| Counter{cSubDelReqToE2, 2}, |
| Counter{cSubDelRespFromE2, 2}, |
| Counter{cRestSubDelRespToXapp, 1}, |
| }) |
| |
| const subReqCount int = 2 |
| |
| // Req |
| params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId) |
| |
| assert.Equal(t, len(e2SubsIds), 2) |
| |
| // Del |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) { |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 1}, |
| Counter{cRestSubRespToXapp, 1}, |
| Counter{cSubReqToE2, 19}, |
| Counter{cSubRespFromE2, 19}, |
| Counter{cRestSubNotifToXapp, 19}, |
| Counter{cRestSubDelReqFromXapp, 1}, |
| Counter{cSubDelReqToE2, 19}, |
| Counter{cSubDelRespFromE2, 19}, |
| Counter{cRestSubDelRespToXapp, 1}, |
| }) |
| |
| const subReqCount int = 19 |
| // Req |
| params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId) |
| |
| assert.Equal(t, len(e2SubsIds), 19) |
| |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) { |
| |
| subReqCount := 2 |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 1}, |
| Counter{cRestSubRespToXapp, 1}, |
| Counter{cSubReqToE2, uint64(subReqCount)}, |
| Counter{cSubRespFromE2, uint64(subReqCount)}, |
| Counter{cRestSubNotifToXapp, uint64(subReqCount)}, |
| Counter{cRestSubDelReqFromXapp, 1}, |
| Counter{cSubDelReqToE2, uint64(subReqCount)}, |
| Counter{cSubDelRespFromE2, uint64(subReqCount)}, |
| Counter{cRestSubDelRespToXapp, 1}, |
| }) |
| |
| // Req |
| params := xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId) |
| |
| assert.Equal(t, len(e2SubsIds), subReqCount) |
| |
| // Del |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) { |
| |
| subReqCount := 2 |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 1}, |
| Counter{cRestSubRespToXapp, 1}, |
| Counter{cSubReqToE2, uint64(subReqCount)}, |
| Counter{cSubRespFromE2, uint64(subReqCount)}, |
| Counter{cRestSubNotifToXapp, uint64(subReqCount)}, |
| Counter{cRestSubDelReqFromXapp, 1}, |
| Counter{cSubDelReqToE2, uint64(subReqCount)}, |
| Counter{cSubDelRespFromE2, uint64(subReqCount)}, |
| Counter{cRestSubDelRespToXapp, 1}, |
| }) |
| |
| // Req |
| params := xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId) |
| |
| assert.Equal(t, len(e2SubsIds), subReqCount) |
| |
| // Del |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) { |
| |
| subReqCount := 19 |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 1}, |
| Counter{cRestSubRespToXapp, 1}, |
| Counter{cSubReqToE2, uint64(subReqCount)}, |
| Counter{cSubRespFromE2, uint64(subReqCount)}, |
| Counter{cRestSubNotifToXapp, uint64(subReqCount)}, |
| Counter{cRestSubDelReqFromXapp, 1}, |
| Counter{cSubDelReqToE2, uint64(subReqCount)}, |
| Counter{cSubDelRespFromE2, uint64(subReqCount)}, |
| Counter{cRestSubDelRespToXapp, 1}, |
| }) |
| |
| // Req |
| params := xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId) |
| |
| assert.Equal(t, len(e2SubsIds), subReqCount) |
| |
| // Del |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) { |
| CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 2}, |
| Counter{cRestSubRespToXapp, 2}, |
| Counter{cSubReqToE2, 2}, |
| Counter{cSubRespFromE2, 2}, |
| Counter{cRestSubNotifToXapp, 2}, |
| Counter{cRestSubDelReqFromXapp, 2}, |
| Counter{cSubDelReqToE2, 2}, |
| Counter{cSubDelRespFromE2, 2}, |
| Counter{cRestSubDelRespToXapp, 2}, |
| }) |
| |
| // Req1 |
| var params *teststube2ap.RESTSubsReqParams = nil |
| |
| //Subs Create |
| restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) |
| 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) |
| params.SetMeid("RAN_NAME_1") |
| eventTriggerDefinition := []int64{1234, 1} |
| params.SetSubEventTriggerDefinition(eventTriggerDefinition) |
| |
| restSubId2 := xappConn2.SendRESTSubsReq(t, params) |
| 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) |
| e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) |
| |
| deleteXapp1Subscription(t, &restSubId1) |
| deleteXapp2Subscription(t, &restSubId2) |
| |
| waitSubsCleanup(t, e2SubsId1, 10) |
| waitSubsCleanup(t, e2SubsId2, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| |
| } |
| |
| func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) { |
| CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 2}, |
| Counter{cRestSubRespToXapp, 2}, |
| Counter{cSubReqToE2, 2}, |
| Counter{cSubRespFromE2, 2}, |
| Counter{cRestSubNotifToXapp, 2}, |
| Counter{cRestSubDelReqFromXapp, 2}, |
| Counter{cSubDelReqToE2, 2}, |
| Counter{cSubDelRespFromE2, 2}, |
| Counter{cRestSubDelRespToXapp, 2}, |
| }) |
| |
| // Req1 |
| var params *teststube2ap.RESTSubsReqParams = nil |
| |
| //Subs Create |
| restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) |
| 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) |
| params.SetMeid("RAN_NAME_1") |
| |
| actionId := int64(1) |
| actionType := "report" |
| actionDefinition := []int64{5678, 1} |
| subsequestActionType := "continue" |
| timeToWait := "w10ms" |
| params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait) |
| |
| restSubId2 := xappConn2.SendRESTSubsReq(t, params) |
| 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) |
| e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) |
| |
| deleteXapp1Subscription(t, &restSubId1) |
| deleteXapp2Subscription(t, &restSubId2) |
| |
| waitSubsCleanup(t, e2SubsId1, 10) |
| waitSubsCleanup(t, e2SubsId2, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| |
| } |
| |
| func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) { |
| CaseBegin("TestRESTSubReqReportSameActionDiffActionID") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 2}, |
| Counter{cRestSubRespToXapp, 2}, |
| Counter{cSubReqToE2, 2}, |
| Counter{cSubRespFromE2, 2}, |
| Counter{cRestSubNotifToXapp, 2}, |
| Counter{cRestSubDelReqFromXapp, 2}, |
| Counter{cSubDelReqToE2, 2}, |
| Counter{cSubDelRespFromE2, 2}, |
| Counter{cRestSubDelRespToXapp, 2}, |
| }) |
| |
| // Req1 |
| var params *teststube2ap.RESTSubsReqParams = nil |
| |
| //Subs Create |
| restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) |
| 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) |
| params.SetMeid("RAN_NAME_1") |
| params.SetSubActionIDs(int64(2)) |
| |
| restSubId2 := xappConn2.SendRESTSubsReq(t, params) |
| 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) |
| e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) |
| |
| deleteXapp1Subscription(t, &restSubId1) |
| deleteXapp2Subscription(t, &restSubId2) |
| |
| waitSubsCleanup(t, e2SubsId1, 10) |
| waitSubsCleanup(t, e2SubsId2, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| |
| } |
| |
| func TestRESTSubReqDiffActionType(t *testing.T) { |
| CaseBegin("TestRESTSubReqDiffActionType") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 2}, |
| Counter{cRestSubRespToXapp, 2}, |
| Counter{cSubReqToE2, 2}, |
| Counter{cSubRespFromE2, 2}, |
| Counter{cRestSubNotifToXapp, 2}, |
| Counter{cRestSubDelReqFromXapp, 2}, |
| Counter{cSubDelReqToE2, 2}, |
| Counter{cSubDelRespFromE2, 2}, |
| Counter{cRestSubDelRespToXapp, 2}, |
| }) |
| |
| const e2Timeout int64 = 2 |
| const e2RetryCount int64 = 2 |
| const routingNeeded bool = true |
| |
| // Req1 |
| params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) |
| params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded) |
| |
| //Subs Create |
| restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) |
| 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) |
| params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded) |
| params.SetMeid("RAN_NAME_1") |
| |
| restSubId2 := xappConn2.SendRESTSubsReq(t, params) |
| 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) |
| e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) |
| |
| deleteXapp1Subscription(t, &restSubId1) |
| deleteXapp2Subscription(t, &restSubId2) |
| |
| waitSubsCleanup(t, e2SubsId1, 10) |
| waitSubsCleanup(t, e2SubsId2, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| |
| } |
| |
| func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) { |
| CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 2}, |
| Counter{cRestSubRespToXapp, 2}, |
| Counter{cSubReqToE2, 2}, |
| Counter{cSubRespFromE2, 2}, |
| Counter{cRestSubNotifToXapp, 2}, |
| Counter{cRestSubDelReqFromXapp, 2}, |
| Counter{cSubDelReqToE2, 2}, |
| Counter{cSubDelRespFromE2, 2}, |
| Counter{cRestSubDelRespToXapp, 2}, |
| }) |
| |
| const e2Timeout int64 = 2 |
| const e2RetryCount int64 = 2 |
| const routingNeeded bool = true |
| |
| // Req1 |
| params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) |
| params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded) |
| |
| //Subs Create |
| restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) |
| 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) |
| params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded) |
| params.SetMeid("RAN_NAME_1") |
| |
| restSubId2 := xappConn2.SendRESTSubsReq(t, params) |
| 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) |
| e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) |
| |
| deleteXapp1Subscription(t, &restSubId1) |
| deleteXapp2Subscription(t, &restSubId2) |
| |
| waitSubsCleanup(t, e2SubsId1, 10) |
| waitSubsCleanup(t, e2SubsId2, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| |
| } |
| |
| func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) { |
| CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 2}, |
| Counter{cRestSubRespToXapp, 2}, |
| Counter{cSubReqToE2, 2}, |
| Counter{cSubRespFromE2, 2}, |
| Counter{cRestSubNotifToXapp, 2}, |
| Counter{cRestSubDelReqFromXapp, 2}, |
| Counter{cSubDelReqToE2, 2}, |
| Counter{cSubDelRespFromE2, 2}, |
| Counter{cRestSubDelRespToXapp, 2}, |
| }) |
| |
| // Req1 |
| var params *teststube2ap.RESTSubsReqParams = nil |
| |
| //Subs Create |
| restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) |
| 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) |
| params.SetMeid("RAN_NAME_1") |
| actionDefinition := []int64{5678, 1} |
| params.SetSubActionDefinition(actionDefinition) |
| |
| restSubId2 := xappConn2.SendRESTSubsReq(t, params) |
| 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) |
| e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) |
| |
| deleteXapp1Subscription(t, &restSubId1) |
| deleteXapp2Subscription(t, &restSubId2) |
| |
| waitSubsCleanup(t, e2SubsId1, 10) |
| waitSubsCleanup(t, e2SubsId2, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| |
| } |
| |
| func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) { |
| CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 2}, |
| Counter{cRestSubRespToXapp, 2}, |
| Counter{cSubReqToE2, 2}, |
| Counter{cSubRespFromE2, 2}, |
| Counter{cRestSubNotifToXapp, 2}, |
| Counter{cRestSubDelReqFromXapp, 2}, |
| Counter{cSubDelReqToE2, 2}, |
| Counter{cSubDelRespFromE2, 2}, |
| Counter{cRestSubDelRespToXapp, 2}, |
| }) |
| |
| // Req1 |
| var params *teststube2ap.RESTSubsReqParams = nil |
| |
| //Subs Create |
| restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) |
| 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) |
| params.SetMeid("RAN_NAME_1") |
| actionDefinition := []int64{56782} |
| params.SetSubActionDefinition(actionDefinition) |
| |
| restSubId2 := xappConn2.SendRESTSubsReq(t, params) |
| 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) |
| e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) |
| |
| deleteXapp1Subscription(t, &restSubId1) |
| deleteXapp2Subscription(t, &restSubId2) |
| |
| waitSubsCleanup(t, e2SubsId1, 10) |
| waitSubsCleanup(t, e2SubsId2, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| |
| } |
| |
| func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) { |
| CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 2}, |
| Counter{cRestSubRespToXapp, 2}, |
| Counter{cSubReqToE2, 2}, |
| Counter{cSubRespFromE2, 2}, |
| Counter{cRestSubNotifToXapp, 2}, |
| Counter{cRestSubDelReqFromXapp, 2}, |
| Counter{cSubDelReqToE2, 2}, |
| Counter{cSubDelRespFromE2, 2}, |
| Counter{cRestSubDelRespToXapp, 2}, |
| }) |
| |
| // Req1 |
| var params *teststube2ap.RESTSubsReqParams = nil |
| |
| //Subs Create |
| restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) |
| 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) |
| params.SetMeid("RAN_NAME_1") |
| params.SetTimeToWait("w200ms") |
| restSubId2 := xappConn2.SendRESTSubsReq(t, params) |
| 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) |
| e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) |
| |
| deleteXapp1Subscription(t, &restSubId1) |
| deleteXapp2Subscription(t, &restSubId2) |
| |
| waitSubsCleanup(t, e2SubsId1, 10) |
| waitSubsCleanup(t, e2SubsId2, 10) |
| |
| mainCtrl.VerifyCounterValues(t) |
| |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTUnpackSubscriptionResponseDecodeFail |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | RestSubReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubResp | | |
| // |<----------------| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubResp | ASN.1 decode fails |
| // | |<-------------| |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubFail | Duplicated action |
| // | |<-------------| |
| // | RESTNotif (fail)| | |
| // |<----------------| | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // |
| //----------------------------------------------------------------------------- |
| |
| func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) { |
| xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseDecodeFail") |
| const subReqCount int = 1 |
| |
| // Req |
| params := xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| // Decode of this response fails which will result resending original request |
| e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP) |
| |
| _, cremsg = e2termConn1.RecvSubsReq(t) |
| |
| xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") |
| |
| // Subscription already created in E2 Node. |
| fparams := &teststube2ap.E2StubSubsFailParams{} |
| fparams.Set(crereq) |
| fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action |
| e2termConn1.SendSubsFail(t, fparams, cremsg) |
| |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| |
| instanceId := xappConn1.WaitRESTNotification(t, restSubId) |
| xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTUnpackSubscriptionResponseUnknownInstanceId |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | RestSubReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubResp | | |
| // |<----------------| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubResp | Unknown instanceId |
| // | |<-------------| |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubFail | Duplicated action |
| // | |<-------------| |
| // | RESTNotif (fail)| | |
| // |<----------------| | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // |
| //----------------------------------------------------------------------------- |
| |
| func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) { |
| xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId") |
| const subReqCount int = 1 |
| |
| // Req |
| params := xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| |
| // Unknown instanceId in this response which will result resending original request |
| orgInstanceId := crereq.RequestId.InstanceId |
| crereq.RequestId.InstanceId = 0 |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| |
| _, cremsg = e2termConn1.RecvSubsReq(t) |
| |
| xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") |
| |
| // Subscription already created in E2 Node. |
| fparams := &teststube2ap.E2StubSubsFailParams{} |
| fparams.Set(crereq) |
| fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action |
| e2termConn1.SendSubsFail(t, fparams, cremsg) |
| |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| |
| instanceId := xappConn1.WaitRESTNotification(t, restSubId) |
| xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, orgInstanceId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTUnpackSubscriptionResponseNoTransaction |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | RestSubReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubResp | | |
| // |<----------------| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubResp | No transaction for the response |
| // | |<-------------| |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubFail | Duplicated action |
| // | |<-------------| |
| // | RESTNotif (fail)| | |
| // |<----------------| | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) { |
| xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseNoTransaction") |
| const subReqCount int = 1 |
| |
| // Req |
| params := xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| |
| mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId) |
| // No transaction exist for this response which will result resending original request |
| e2termConn1.SendSubsResp(t, crereq, cremsg) |
| |
| _, cremsg = e2termConn1.RecvSubsReq(t) |
| |
| xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") |
| |
| // Subscription already created in E2 Node. |
| fparams := &teststube2ap.E2StubSubsFailParams{} |
| fparams.Set(crereq) |
| fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action |
| e2termConn1.SendSubsFail(t, fparams, cremsg) |
| |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| |
| // Resending happens because there no transaction |
| delreq, delmsg = e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| |
| instanceId := xappConn1.WaitRESTNotification(t, restSubId) |
| xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTUnpackSubscriptionFailureDecodeFail |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | RestSubReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubResp | | |
| // |<----------------| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubFail | ASN.1 decode fails |
| // | |<-------------| |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubFail | Duplicated action |
| // | |<-------------| |
| // | RESTNotif (fail)| | |
| // |<----------------| | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) { |
| xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureDecodeFail") |
| const subReqCount int = 1 |
| |
| // Req |
| params := xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| |
| // Decode of this response fails which will result resending original request |
| e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE) |
| |
| _, cremsg = e2termConn1.RecvSubsReq(t) |
| |
| xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") |
| |
| // Subscription already created in E2 Node. |
| fparams := &teststube2ap.E2StubSubsFailParams{} |
| fparams.Set(crereq) |
| fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action |
| e2termConn1.SendSubsFail(t, fparams, cremsg) |
| |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| |
| instanceId := xappConn1.WaitRESTNotification(t, restSubId) |
| xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTUnpackSubscriptionResponseUnknownInstanceId |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | RestSubReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubResp | | |
| // |<----------------| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubFail | Unknown instanceId |
| // | |<-------------| |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubFail | Duplicated action |
| // | |<-------------| |
| // | RESTNotif (fail)| | |
| // |<----------------| | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) { |
| xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId") |
| const subReqCount int = 1 |
| |
| // Req |
| params := xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| |
| // Unknown instanceId in this response which will result resending original request |
| fparams := &teststube2ap.E2StubSubsFailParams{} |
| fparams.Set(crereq) |
| fparams.Fail.RequestId.InstanceId = 0 |
| e2termConn1.SendSubsFail(t, fparams, cremsg) |
| |
| _, cremsg = e2termConn1.RecvSubsReq(t) |
| |
| xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") |
| |
| // Subscription already created in E2 Node. |
| fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action |
| e2termConn1.SendSubsFail(t, fparams, cremsg) |
| |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| |
| instanceId := xappConn1.WaitRESTNotification(t, restSubId) |
| xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTUnpackSubscriptionFailureNoTransaction |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | RestSubReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubResp | | |
| // |<----------------| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubFail | No transaction for the response |
| // | |<-------------| |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubFail | Duplicated action |
| // | |<-------------| |
| // | RESTNotif (fail)| | |
| // |<----------------| | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) { |
| xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureNoTransaction") |
| const subReqCount int = 1 |
| |
| // Req |
| params := xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| |
| crereq, cremsg := e2termConn1.RecvSubsReq(t) |
| |
| mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId) |
| |
| // No transaction exist for this response which will result resending original request |
| fparams := &teststube2ap.E2StubSubsFailParams{} |
| fparams.Set(crereq) |
| e2termConn1.SendSubsFail(t, fparams, cremsg) |
| |
| _, cremsg = e2termConn1.RecvSubsReq(t) |
| |
| xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") |
| |
| // Subscription already created in E2 Node. |
| fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action |
| e2termConn1.SendSubsFail(t, fparams, cremsg) |
| |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| |
| // Resending happens because there no transaction |
| delreq, delmsg = e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| |
| instanceId := xappConn1.WaitRESTNotification(t, restSubId) |
| xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTUnpackSubscriptionDeleteResponseDecodeFail |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | [SUBS CREATE] | |
| // | | | |
| // | | | |
| // | RESTSubDelReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubDelResp | | |
| // |<----------------| | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | ASN.1 decode fails |
| // | |<-------------| |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelFail | Subscription does exist any more |
| // | |<-------------| |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) { |
| xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail") |
| |
| // Req |
| var params *teststube2ap.RESTSubsReqParams = nil |
| restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) |
| |
| // Del |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| |
| // E2t: Receive 1st SubsDelReq |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| |
| // Decode of this response fails which will result resending original request |
| e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_REQ) |
| |
| // E2t: Receive 2nd SubsDelReq and send SubsDelResp |
| delreq, delmsg = e2termConn1.RecvSubsDelReq(t) |
| |
| // Subscription does not exist in in E2 Node. |
| e2termConn1.SendSubsDelFail(t, delreq, delmsg) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | [SUBS CREATE] | |
| // | | | |
| // | | | |
| // | RESTSubDelReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubDelResp | | |
| // |<----------------| | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | Unknown instanceId |
| // | |<-------------| |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelFail | Subscription does exist any more |
| // | |<-------------| |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) { |
| xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId") |
| |
| // Req |
| var params *teststube2ap.RESTSubsReqParams = nil |
| restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) |
| |
| // Del |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| |
| // E2t: Receive 1st SubsDelReq |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| |
| // Unknown instanceId in this response which will result resending original request |
| delreq.RequestId.InstanceId = 0 |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| |
| // E2t: Receive 2nd SubsDelReq |
| delreq, delmsg = e2termConn1.RecvSubsDelReq(t) |
| |
| // Subscription does not exist in in E2 Node. |
| e2termConn1.SendSubsDelFail(t, delreq, delmsg) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTUnpackSubscriptionDeleteResponseNoTransaction |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | [SUBS CREATE] | |
| // | | | |
| // | | | |
| // | RESTSubDelReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubDelResp | | |
| // |<----------------| | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | No transaction for the response |
| // | |<-------------| |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelFail | Subscription does exist any more |
| // | |<-------------| |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) { |
| xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction") |
| |
| // Req |
| var params *teststube2ap.RESTSubsReqParams = nil |
| restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) |
| |
| // Del |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| |
| // E2t: Receive 1st SubsDelReq |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| |
| mainCtrl.MakeTransactionNil(t, e2SubsId) |
| |
| // No transaction exist for this response which will result resending original request |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| |
| // E2t: Receive 2nd SubsDelReq |
| delreq, delmsg = e2termConn1.RecvSubsDelReq(t) |
| |
| // Subscription does not exist in in E2 Node. |
| e2termConn1.SendSubsDelFail(t, delreq, delmsg) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTUnpackSubscriptionDeleteFailureDecodeFail |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | [SUBS CREATE] | |
| // | | | |
| // | | | |
| // | RESTSubDelReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubDelResp | | |
| // |<----------------| | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelFail | ASN.1 decode fails |
| // | |<-------------| |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelFail | Subscription does exist any more |
| // | |<-------------| |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) { |
| xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail") |
| |
| // Req |
| var params *teststube2ap.RESTSubsReqParams = nil |
| restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) |
| |
| // Del |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| |
| // E2t: Receive 1st SubsDelReq |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| |
| // Decode of this response fails which will result resending original request |
| e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE) |
| |
| // E2t: Receive 2nd SubsDelReq and send SubsDelResp |
| delreq, delmsg = e2termConn1.RecvSubsDelReq(t) |
| |
| // Subscription does not exist in in E2 Node. |
| e2termConn1.SendSubsDelFail(t, delreq, delmsg) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | [SUBS CREATE] | |
| // | | | |
| // | | | |
| // | RESTSubDelReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubDelResp | | |
| // |<----------------| | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelFail | Unknown instanceId |
| // | |<-------------| |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelFail | Subscription does exist any more |
| // | |<-------------| |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) { |
| xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId") |
| |
| // Req |
| var params *teststube2ap.RESTSubsReqParams = nil |
| restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) |
| |
| // Del |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| |
| // E2t: Receive 1st SubsDelReq |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| |
| // Unknown instanceId in this response which will result resending original request |
| delreq.RequestId.InstanceId = 0 |
| e2termConn1.SendSubsDelFail(t, delreq, delmsg) |
| |
| // E2t: Receive 2nd SubsDelReq |
| delreq, delmsg = e2termConn1.RecvSubsDelReq(t) |
| |
| // Subscription does not exist in in E2 Node. |
| e2termConn1.SendSubsDelFail(t, delreq, delmsg) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTUnpackSubscriptionDeleteFailureNoTransaction |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | [SUBS CREATE] | |
| // | | | |
| // | | | |
| // | RESTSubDelReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubDelResp | | |
| // |<----------------| | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelFail | No transaction for the response |
| // | |<-------------| |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelFail | Subscription does exist any more |
| // | |<-------------| |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) { |
| xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction") |
| |
| // Req |
| var params *teststube2ap.RESTSubsReqParams = nil |
| restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) |
| |
| // Del |
| xappConn1.SendRESTSubsDelReq(t, &restSubId) |
| |
| // E2t: Receive 1st SubsDelReq |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| |
| mainCtrl.MakeTransactionNil(t, e2SubsId) |
| |
| // No transaction exist for this response which will result resending original request |
| e2termConn1.SendSubsDelFail(t, delreq, delmsg) |
| |
| // E2t: Receive 2nd SubsDelReq |
| delreq, delmsg = e2termConn1.RecvSubsDelReq(t) |
| |
| // Subscription does not exist in in E2 Node. |
| e2termConn1.SendSubsDelFail(t, delreq, delmsg) |
| |
| // Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, 10) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, 10) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestRESTSubReqFailAsn1PackSubReqError |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | RESTSubReq | | |
| // |---------------->| | |
| // | | | |
| // | RESTSubResp | | |
| // |<----------------| | |
| // | | | |
| // | ASN.1 encode fails | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelFail | |
| // | |<-------------| |
| // | | | |
| // | RESTNotif | | |
| // | unsuccess | | |
| // |<----------------| | |
| // | | | |
| // | [SUBS DELETE] | |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) { |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 1}, |
| Counter{cRestSubRespToXapp, 1}, |
| Counter{cRestSubFailNotifToXapp, 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) |
| // Wait that subs is cleaned |
| waitSubsCleanup(t, e2SubsId, 10) |
| mainCtrl.VerifyCounterValues(t) |
| } |
| |
| func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) { |
| CaseBegin("TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction") |
| |
| mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ |
| Counter{cRestSubReqFromXapp, 2}, |
| Counter{cRestSubRespToXapp, 2}, |
| Counter{cSubReqToE2, 2}, |
| 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.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{cRestSubNotifToXapp, 1}, |
| Counter{cRestSubDelReqFromXapp, 1}, |
| Counter{cSubDelReqToE2, 1}, |
| Counter{cRestSubDelRespToXapp, 1}, |
| }) |
| |
| // Remove possible existing subscription |
| mainCtrl.removeExistingSubscriptions(t) |
| |
| 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") |
| |
| // Check subscription |
| queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"}) |
| |
| xapp.Logger.Debug("Here 1") |
| //<-time.After(3 * time.Second) |
| xapp.Logger.Debug("Here 2") |
| |
| // 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) |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////// |
| // Services for UT cases |
| //////////////////////////////////////////////////////////////////////////////////// |
| const subReqCount 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) |
| } |
| restSubId := fromXappConn.SendRESTSubsReq(t, params) |
| 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.Debug("REST notification received e2SubsId=%v", e2SubsId) |
| |
| return restSubId, e2SubsId |
| } |
| |
| func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) { |
| |
| 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.Debug("Send REST subscriber request for subscriberId : %v", restSubId) |
| e2SubsId := xappConn2.WaitRESTNotification(t, restSubId) |
| xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId) |
| |
| return restSubId, e2SubsId |
| } |
| |
| func createXapp1PolicySubscription(t *testing.T) (string, uint32) { |
| |
| params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| 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.Debug("REST notification received e2SubsId=%v", e2SubsId) |
| |
| return restSubId, e2SubsId |
| } |
| |
| func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) { |
| params := xappConn1.GetRESTSubsReqReportParams(subReqCount) |
| restSubId := xappConn1.SendRESTSubsReq(t, params) |
| |
| crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) |
| fparams1 := &teststube2ap.E2StubSubsFailParams{} |
| fparams1.Set(crereq1) |
| 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.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId) |
| |
| return restSubId, e2SubsId |
| } |
| |
| func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) { |
| fromXappConn.SendRESTSubsDelReq(t, restSubId) |
| delreq, delmsg := toE2termConn.RecvSubsDelReq(t) |
| toE2termConn.SendSubsDelResp(t, delreq, delmsg) |
| } |
| |
| func deleteXapp1Subscription(t *testing.T, restSubId *string) { |
| xappConn1.SendRESTSubsDelReq(t, restSubId) |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| } |
| |
| func deleteXapp2Subscription(t *testing.T, restSubId *string) { |
| xappConn2.SendRESTSubsDelReq(t, restSubId) |
| delreq, delmsg := e2termConn1.RecvSubsDelReq(t) |
| e2termConn1.SendSubsDelResp(t, delreq, delmsg) |
| } |
| |
| 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) |
| } |
| |
| func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) { |
| //Wait that subs is cleaned |
| mainCtrl.wait_subs_clean(t, e2SubsId, timeout) |
| |
| xappConn1.TestMsgChanEmpty(t) |
| xappConn2.TestMsgChanEmpty(t) |
| e2termConn1.TestMsgChanEmpty(t) |
| mainCtrl.wait_registry_empty(t, timeout) |
| } |
| |
| func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 { |
| |
| var e2SubsId []uint32 |
| |
| for i := 0; i < count; i++ { |
| 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.Debug("TEST: %v", e2SubsId) |
| xapp.Logger.Debug("TEST: %d ===================================== END CRE ============================================", i+1) |
| <-time.After(100 * time.Millisecond) |
| } |
| return e2SubsId |
| } |
| |
| func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) { |
| |
| for i := 0; i < len(e2SubsIds); i++ { |
| 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.Debug("TEST: %d ===================================== END DEL ============================================", i+1) |
| <-time.After(100 * time.Millisecond) |
| } |
| |
| // Wait that subs is cleaned |
| for i := 0; i < len(e2SubsIds); i++ { |
| mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10) |
| } |
| |
| } |