/* ================================================================================== 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()) } //----------------------------------------------------------------------------- // 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") 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") } //----------------------------------------------------------------------------- // 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.Info("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.Info("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) | | // |---------------->| | // | | | // | | SubReq2 | // | |------------->| // | RESTSubResp2 | | // |<----------------| | // | | SubResp1 | // | |<-------------| // | RESTNotif1 | | // |<----------------| | // | | SubResp1 | // | |<-------------| // | RESTNotif2 | | // |<----------------| | // | | | // | [SUBS DELETE] | // | | | // //----------------------------------------------------------------------------- func TestRESTSubReqRetransmission(t *testing.T) { CaseBegin("TestRESTSubReqRetransmission") 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}, }) // Retry/duplicate will get the same way as the first request. Submgr cannot detect duplicate RESTRequests // 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) restSubId2 := xappConn2.SendRESTSubsReq(t, params) waiter.WaitResult(t) xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2}) // 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) crereq, cremsg = e2termConn1.RecvSubsReq(t) e2termConn1.SendSubsResp(t, crereq, cremsg) e2SubsIdA := <-xappConn1.ListedRESTNotifications xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA) e2SubsIdB := <-xappConn1.ListedRESTNotifications xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB) // Del1 xappConn1.SendRESTSubsDelReq(t, &restSubId1) delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t) e2termConn1.SendSubsDelResp(t, delreq1, delmsg1) // Del2 xappConn2.SendRESTSubsDelReq(t, &restSubId2) delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t) e2termConn1.SendSubsDelResp(t, delreq2, delmsg2) mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10) waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10) 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.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1) //Req2 params = xappConn2.GetRESTSubsReqReportParams(subReqCount) restSubId2 := xappConn2.SendRESTSubsReq(t, params) xapp.Logger.Info("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.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA) e2SubsIdB := <-xappConn1.ListedRESTNotifications xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB) //Del1 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.Info("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.Info("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.Info("Send REST subscriber request for subscriber : %v", restSubId) // Catch the first message and ignore it crereq, cremsg := e2termConn1.RecvSubsReq(t) xapp.Logger.Info("Ignore REST subscriber request for subscriber : %v", restSubId) // 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.Info("Send REST subscriber request for subscriber : %v", restSubId) e2termConn1.RecvSubsReq(t) xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId) e2termConn1.RecvSubsReq(t) xapp.Logger.Info("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.Info("Send REST subscriber request for subscriber : %v", restSubId) e2termConn1.RecvSubsReq(t) xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId) e2termConn1.RecvSubsReq(t) xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId) e2termConn1.RecvSubsDelReq(t) xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId) xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") e2termConn1.RecvSubsDelReq(t) xapp.Logger.Info("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.Info("Send REST subscriber request for subscriber : %v", restSubId) e2termConn1.RecvSubsReq(t) xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId) e2termConn1.RecvSubsReq(t) xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId) e2termConn1.RecvSubsDelReq(t) xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId) xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") e2termConn1.RecvSubsDelReq(t) xapp.Logger.Info("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 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.ExpectRESTNotificationNok(t, restSubId, "allFail") e2termConn1.SendSubsDelResp(t, delreq1, delmsg1) e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) xapp.Logger.Info("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.WaitRESTNotificationForAnySubscriptionId(t) waiter := rtmgrHttp.AllocNextSleep(10, true) restSubId2 := xappConn2.SendRESTSubsReq(t, params) waiter.WaitResult(t) xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) e2SubsId2 := <-xappConn2.RESTNotification xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2) 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.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA) e2SubsIdB := <-xappConn1.ListedRESTNotifications xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB) // Del1 xappConn1.SendRESTSubsDelReq(t, &restSubId1) // 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.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA) e2SubsIdB := <-xappConn1.ListedRESTNotifications xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB) // Del1 xappConn1.SendRESTSubsDelReq(t, &restSubId1) // 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}, }) const subReqCount int = 1 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId) crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) xappConn1.ExpectRESTNotification(t, restSubId) e2termConn1.SendSubsResp(t, crereq1, cremsg1) e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId) 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 // Req params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) // Policy change // GetRESTSubsReqPolicyParams sets some coutners on tc side. params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount) 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 | // | | | // | 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}, }) const subReqCount int = 1 // Req params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) // Policy change params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount) restSubIdUpd := strings.ToUpper(restSubId) 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.Info("TEST: REST notification received e2SubsId1=%v", e2SubsId1) // Resp2 xappConn2.ExpectRESTNotification(t, restSubId2) e2termConn2.SendSubsResp(t, crereq2, cremsg2) e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) xapp.Logger.Info("TEST: REST notification received e2SubsId2=%v", e2SubsId2) // 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.Info("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.Info("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.Info("Send REST subscriber request for subscriber : %v", restSubId) // Check subscription queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"}) // When SDL support for the REST Interface is added // the submgr restart statement below should be removed // from the comment. // mainCtrl.SimulateRestart(t) // xapp.Logger.Debug("mainCtrl.SimulateRestart done") // 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.Info("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.WaitRESTNotificationForAnySubscriptionId(t) restSubId2 := xappConn2.SendRESTSubsReq(t, params) xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) e2SubsId2 := <-xappConn2.RESTNotification xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2) queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"}) // When SDL support for the REST Interface is added // the submgr restart statement below should be removed // from the comment. // mainCtrl.SimulateRestart(t) // xapp.Logger.Debug("mainCtrl.SimulateRestart done") // Delete subscription 1, and wait until it has removed the first endpoint subepcnt := mainCtrl.get_subs_entrypoint_cnt(t, e2SubsId1) xappConn1.SendRESTSubsDelReq(t, &restSubId1) mainCtrl.wait_subs_entrypoint_cnt_change(t, e2SubsId1, subepcnt, 10) // When SDL support for the REST Interface is added // the submgr restart statement below should be removed // from the comment. // 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") subReqCount := 1 testIndex := 1 RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex) } func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) { xapp.Logger.Info("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.Info("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.Info("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex) // Req params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) //params := xappConn1.GetRESTSubsReqPolicyParams1(subReqCount) //restSubId := xappConn1.SendRESTPolicySubsReq(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.Info("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) { subReqCount := 2 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}, }) // 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) { subReqCount := 19 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}, }) // 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.Info("Send REST subscriber request for subscriberId : %v", restSubId1) queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"}) // Req2 params = xappConn2.GetRESTSubsReqReportParams(subReqCount) params.SetMeid("RAN_NAME_1") eventTriggerDefinition := []int64{1234, 1} params.SetSubEventTriggerDefinition(eventTriggerDefinition) restSubId2 := xappConn2.SendRESTSubsReq(t, params) xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) crereq, cremsg := e2termConn1.RecvSubsReq(t) xappConn2.ExpectRESTNotification(t, restSubId2) e2termConn1.SendSubsResp(t, crereq, cremsg) e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) deleteXapp1Subscription(t, &restSubId1) deleteXapp2Subscription(t, &restSubId2) waitSubsCleanup(t, e2SubsId1, 10) waitSubsCleanup(t, e2SubsId2, 10) mainCtrl.VerifyCounterValues(t) } func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) { CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ Counter{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.Info("Send REST subscriber request for subscriberId : %v", restSubId1) queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"}) // Req2 params = xappConn2.GetRESTSubsReqReportParams(subReqCount) params.SetMeid("RAN_NAME_1") actionId := int64(1) actionType := "report" actionDefinition := []int64{5678, 1} subsequestActionType := "continue" timeToWait := "w10ms" params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait) restSubId2 := xappConn2.SendRESTSubsReq(t, params) xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) 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.Info("Send REST subscriber request for subscriberId : %v", restSubId1) queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"}) // Req2 params = xappConn2.GetRESTSubsReqReportParams(subReqCount) params.SetMeid("RAN_NAME_1") params.SetSubActionIDs(int64(2)) restSubId2 := xappConn2.SendRESTSubsReq(t, params) xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) crereq, cremsg := e2termConn1.RecvSubsReq(t) xappConn2.ExpectRESTNotification(t, restSubId2) e2termConn1.SendSubsResp(t, crereq, cremsg) e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) deleteXapp1Subscription(t, &restSubId1) deleteXapp2Subscription(t, &restSubId2) waitSubsCleanup(t, e2SubsId1, 10) waitSubsCleanup(t, e2SubsId2, 10) mainCtrl.VerifyCounterValues(t) } func TestRESTSubReqDiffActionType(t *testing.T) { CaseBegin("TestRESTSubReqDiffActionType") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ Counter{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.GetRESTSubsReqPolicyParams(subReqCount) //Subs Create restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1) queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"}) // Req2 params = xappConn2.GetRESTSubsReqReportParams(subReqCount) params.SetMeid("RAN_NAME_1") restSubId2 := xappConn2.SendRESTSubsReq(t, params) xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) crereq, cremsg := e2termConn1.RecvSubsReq(t) xappConn2.ExpectRESTNotification(t, restSubId2) e2termConn1.SendSubsResp(t, crereq, cremsg) e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) deleteXapp1Subscription(t, &restSubId1) deleteXapp2Subscription(t, &restSubId2) waitSubsCleanup(t, e2SubsId1, 10) waitSubsCleanup(t, e2SubsId2, 10) mainCtrl.VerifyCounterValues(t) } func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) { CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ Counter{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.GetRESTSubsReqPolicyParams(subReqCount) //Subs Create restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params) xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1) queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"}) // Req2 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount) params.SetMeid("RAN_NAME_1") restSubId2 := xappConn2.SendRESTSubsReq(t, params) xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) crereq, cremsg := e2termConn1.RecvSubsReq(t) xappConn2.ExpectRESTNotification(t, restSubId2) e2termConn1.SendSubsResp(t, crereq, cremsg) e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) deleteXapp1Subscription(t, &restSubId1) deleteXapp2Subscription(t, &restSubId2) waitSubsCleanup(t, e2SubsId1, 10) waitSubsCleanup(t, e2SubsId2, 10) mainCtrl.VerifyCounterValues(t) } func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) { CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ Counter{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.Info("Send REST subscriber request for subscriberId : %v", restSubId1) queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"}) // Req2 params = xappConn2.GetRESTSubsReqReportParams(subReqCount) params.SetMeid("RAN_NAME_1") actionDefinition := []int64{5678, 1} params.SetSubActionDefinition(actionDefinition) restSubId2 := xappConn2.SendRESTSubsReq(t, params) xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) crereq, cremsg := e2termConn1.RecvSubsReq(t) xappConn2.ExpectRESTNotification(t, restSubId2) e2termConn1.SendSubsResp(t, crereq, cremsg) e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) deleteXapp1Subscription(t, &restSubId1) deleteXapp2Subscription(t, &restSubId2) waitSubsCleanup(t, e2SubsId1, 10) waitSubsCleanup(t, e2SubsId2, 10) mainCtrl.VerifyCounterValues(t) } func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) { CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ Counter{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.Info("Send REST subscriber request for subscriberId : %v", restSubId1) queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"}) // Req2 params = xappConn2.GetRESTSubsReqReportParams(subReqCount) params.SetMeid("RAN_NAME_1") actionDefinition := []int64{56782} params.SetSubActionDefinition(actionDefinition) restSubId2 := xappConn2.SendRESTSubsReq(t, params) xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) crereq, cremsg := e2termConn1.RecvSubsReq(t) xappConn2.ExpectRESTNotification(t, restSubId2) e2termConn1.SendSubsResp(t, crereq, cremsg) e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) deleteXapp1Subscription(t, &restSubId1) deleteXapp2Subscription(t, &restSubId2) waitSubsCleanup(t, e2SubsId1, 10) waitSubsCleanup(t, e2SubsId2, 10) mainCtrl.VerifyCounterValues(t) } func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) { CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction") mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ Counter{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.Info("Send REST subscriber request for subscriberId : %v", restSubId1) queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"}) // Req2 params = xappConn2.GetRESTSubsReqReportParams(subReqCount) params.SetMeid("RAN_NAME_1") params.SetTimeToWait("w200ms") restSubId2 := xappConn2.SendRESTSubsReq(t, params) xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2) crereq, cremsg := e2termConn1.RecvSubsReq(t) xappConn2.ExpectRESTNotification(t, restSubId2) e2termConn1.SendSubsResp(t, crereq, cremsg) e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) deleteXapp1Subscription(t, &restSubId1) deleteXapp2Subscription(t, &restSubId2) waitSubsCleanup(t, e2SubsId1, 10) waitSubsCleanup(t, e2SubsId2, 10) mainCtrl.VerifyCounterValues(t) } //----------------------------------------------------------------------------- // TestRESTUnpackSubscriptionResponseDecodeFail // // stub stub // +-------+ +---------+ +---------+ // | xapp | | submgr | | e2term | // +-------+ +---------+ +---------+ // | | | // | RestSubReq | | // |---------------->| | // | | | // | RESTSubResp | | // |<----------------| | // | | | // | | SubReq | // | |------------->| // | | | // | | SubResp | ASN.1 decode fails // | |<-------------| // | | | // | | SubReq | // | |------------->| // | | | // | | SubFail | Duplicated action // | |<-------------| // | RESTNotif (fail)| | // |<----------------| | // | | SubDelReq | // | |------------->| // | | | // | | SubDelResp | // | |<-------------| // //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) { xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseDecodeFail") subReqCount := 1 // Req params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) crereq, cremsg := e2termConn1.RecvSubsReq(t) // Decode of this response fails which will result resending original request e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP) _, cremsg = e2termConn1.RecvSubsReq(t) xappConn1.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.Info("TEST: REST notification received e2SubsId=%v", instanceId) // Wait that subs is cleaned mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10) xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) } //----------------------------------------------------------------------------- // TestRESTUnpackSubscriptionResponseUnknownInstanceId // // stub stub // +-------+ +---------+ +---------+ // | xapp | | submgr | | e2term | // +-------+ +---------+ +---------+ // | | | // | RestSubReq | | // |---------------->| | // | | | // | RESTSubResp | | // |<----------------| | // | | | // | | SubReq | // | |------------->| // | | | // | | SubResp | Unknown instanceId // | |<-------------| // | | | // | | SubReq | // | |------------->| // | | | // | | SubFail | Duplicated action // | |<-------------| // | RESTNotif (fail)| | // |<----------------| | // | | SubDelReq | // | |------------->| // | | | // | | SubDelResp | // | |<-------------| // //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) { xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId") subReqCount := 1 // Req params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) crereq, cremsg := e2termConn1.RecvSubsReq(t) // Unknown instanceId in this response which will result resending original request orgInstanceId := crereq.RequestId.InstanceId crereq.RequestId.InstanceId = 0 e2termConn1.SendSubsResp(t, crereq, cremsg) _, cremsg = e2termConn1.RecvSubsReq(t) xappConn1.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.Info("TEST: REST notification received e2SubsId=%v", instanceId) // Wait that subs is cleaned mainCtrl.wait_subs_clean(t, orgInstanceId, 10) xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) } //----------------------------------------------------------------------------- // TestRESTUnpackSubscriptionResponseNoTransaction // // stub stub // +-------+ +---------+ +---------+ // | xapp | | submgr | | e2term | // +-------+ +---------+ +---------+ // | | | // | RestSubReq | | // |---------------->| | // | | | // | RESTSubResp | | // |<----------------| | // | | | // | | SubReq | // | |------------->| // | | | // | | SubResp | No transaction for the response // | |<-------------| // | | | // | | SubReq | // | |------------->| // | | | // | | SubFail | Duplicated action // | |<-------------| // | RESTNotif (fail)| | // |<----------------| | // | | SubDelReq | // | |------------->| // | | | // | | SubDelResp | // | |<-------------| // | | | // | | SubDelReq | // | |------------->| // | | | // | | SubDelResp | // | |<-------------| // //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) { xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseNoTransaction") subReqCount := 1 // Req params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) crereq, cremsg := e2termConn1.RecvSubsReq(t) mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId) // No transaction exist for this response which will result resending original request e2termConn1.SendSubsResp(t, crereq, cremsg) _, cremsg = e2termConn1.RecvSubsReq(t) xappConn1.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.Info("TEST: REST notification received e2SubsId=%v", instanceId) // Wait that subs is cleaned mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10) xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) } //----------------------------------------------------------------------------- // TestRESTUnpackSubscriptionFailureDecodeFail // // stub stub // +-------+ +---------+ +---------+ // | xapp | | submgr | | e2term | // +-------+ +---------+ +---------+ // | | | // | RestSubReq | | // |---------------->| | // | | | // | RESTSubResp | | // |<----------------| | // | | | // | | SubReq | // | |------------->| // | | | // | | SubFail | ASN.1 decode fails // | |<-------------| // | | | // | | SubReq | // | |------------->| // | | | // | | SubFail | Duplicated action // | |<-------------| // | RESTNotif (fail)| | // |<----------------| | // | | SubDelReq | // | |------------->| // | | | // | | SubDelResp | // | |<-------------| // //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) { xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureDecodeFail") subReqCount := 1 // Req params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) crereq, cremsg := e2termConn1.RecvSubsReq(t) // Decode of this response fails which will result resending original request e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE) _, cremsg = e2termConn1.RecvSubsReq(t) xappConn1.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.Info("TEST: REST notification received e2SubsId=%v", instanceId) // Wait that subs is cleaned mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10) xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) } //----------------------------------------------------------------------------- // TestRESTUnpackSubscriptionResponseUnknownInstanceId // // stub stub // +-------+ +---------+ +---------+ // | xapp | | submgr | | e2term | // +-------+ +---------+ +---------+ // | | | // | RestSubReq | | // |---------------->| | // | | | // | RESTSubResp | | // |<----------------| | // | | | // | | SubReq | // | |------------->| // | | | // | | SubFail | Unknown instanceId // | |<-------------| // | | | // | | SubReq | // | |------------->| // | | | // | | SubFail | Duplicated action // | |<-------------| // | RESTNotif (fail)| | // |<----------------| | // | | SubDelReq | // | |------------->| // | | | // | | SubDelResp | // | |<-------------| // //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) { xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId") subReqCount := 1 // Req params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) crereq, cremsg := e2termConn1.RecvSubsReq(t) // Unknown instanceId in this response which will result resending original request fparams := &teststube2ap.E2StubSubsFailParams{} fparams.Set(crereq) fparams.Fail.RequestId.InstanceId = 0 e2termConn1.SendSubsFail(t, fparams, cremsg) _, cremsg = e2termConn1.RecvSubsReq(t) xappConn1.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.Info("TEST: REST notification received e2SubsId=%v", instanceId) // Wait that subs is cleaned mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10) xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) } //----------------------------------------------------------------------------- // TestRESTUnpackSubscriptionFailureNoTransaction // // stub stub // +-------+ +---------+ +---------+ // | xapp | | submgr | | e2term | // +-------+ +---------+ +---------+ // | | | // | RestSubReq | | // |---------------->| | // | | | // | RESTSubResp | | // |<----------------| | // | | | // | | SubReq | // | |------------->| // | | | // | | SubFail | No transaction for the response // | |<-------------| // | | | // | | SubReq | // | |------------->| // | | | // | | SubFail | Duplicated action // | |<-------------| // | RESTNotif (fail)| | // |<----------------| | // | | SubDelReq | // | |------------->| // | | | // | | SubDelResp | // | |<-------------| // //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) { xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureNoTransaction") subReqCount := 1 // Req params := xappConn1.GetRESTSubsReqReportParams(subReqCount) restSubId := xappConn1.SendRESTSubsReq(t, params) crereq, cremsg := e2termConn1.RecvSubsReq(t) mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId) // No transaction exist for this response which will result resending original request fparams := &teststube2ap.E2StubSubsFailParams{} fparams.Set(crereq) e2termConn1.SendSubsFail(t, fparams, cremsg) _, cremsg = e2termConn1.RecvSubsReq(t) xappConn1.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.Info("TEST: REST notification received e2SubsId=%v", instanceId) // Wait that subs is cleaned mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10) xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) } //----------------------------------------------------------------------------- // TestRESTUnpackSubscriptionDeleteResponseDecodeFail // // stub stub // +-------+ +---------+ +---------+ // | xapp | | submgr | | e2term | // +-------+ +---------+ +---------+ // | | | // | [SUBS CREATE] | // | | | // | | | // | RESTSubDelReq | | // |---------------->| | // | | | // | RESTSubDelResp | | // |<----------------| | // | | | // | | SubDelReq | // | |------------->| // | | | // | | SubDelResp | ASN.1 decode fails // | |<-------------| // | | | // | | SubDelReq | // | |------------->| // | | | // | | SubDelFail | Subscription does exist any more // | |<-------------| // | | | // //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) { xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail") // Req var params *teststube2ap.RESTSubsReqParams = nil restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) // Del xappConn1.SendRESTSubsDelReq(t, &restSubId) // E2t: Receive 1st SubsDelReq delreq, delmsg := e2termConn1.RecvSubsDelReq(t) // Decode of this response fails which will result resending original request e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_REQ) // E2t: Receive 2nd SubsDelReq and send SubsDelResp delreq, delmsg = e2termConn1.RecvSubsDelReq(t) // Subscription does not exist in in E2 Node. e2termConn1.SendSubsDelFail(t, delreq, delmsg) // Wait that subs is cleaned mainCtrl.wait_subs_clean(t, e2SubsId, 10) xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) } //----------------------------------------------------------------------------- // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId // // stub stub // +-------+ +---------+ +---------+ // | xapp | | submgr | | e2term | // +-------+ +---------+ +---------+ // | | | // | [SUBS CREATE] | // | | | // | | | // | RESTSubDelReq | | // |---------------->| | // | | | // | RESTSubDelResp | | // |<----------------| | // | | | // | | SubDelReq | // | |------------->| // | | | // | | SubDelResp | Unknown instanceId // | |<-------------| // | | | // | | SubDelReq | // | |------------->| // | | | // | | SubDelFail | Subscription does exist any more // | |<-------------| // //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) { xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId") // Req var params *teststube2ap.RESTSubsReqParams = nil restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) // Del xappConn1.SendRESTSubsDelReq(t, &restSubId) // E2t: Receive 1st SubsDelReq delreq, delmsg := e2termConn1.RecvSubsDelReq(t) // Unknown instanceId in this response which will result resending original request delreq.RequestId.InstanceId = 0 e2termConn1.SendSubsDelResp(t, delreq, delmsg) // E2t: Receive 2nd SubsDelReq delreq, delmsg = e2termConn1.RecvSubsDelReq(t) // Subscription does not exist in in E2 Node. e2termConn1.SendSubsDelFail(t, delreq, delmsg) // Wait that subs is cleaned mainCtrl.wait_subs_clean(t, e2SubsId, 10) xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) } //----------------------------------------------------------------------------- // TestRESTUnpackSubscriptionDeleteResponseNoTransaction // // stub stub // +-------+ +---------+ +---------+ // | xapp | | submgr | | e2term | // +-------+ +---------+ +---------+ // | | | // | [SUBS CREATE] | // | | | // | | | // | RESTSubDelReq | | // |---------------->| | // | | | // | RESTSubDelResp | | // |<----------------| | // | | | // | | SubDelReq | // | |------------->| // | | | // | | SubDelResp | No transaction for the response // | |<-------------| // | | | // | | SubDelReq | // | |------------->| // | | | // | | SubDelFail | Subscription does exist any more // | |<-------------| // //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) { xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction") // Req var params *teststube2ap.RESTSubsReqParams = nil restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) // Del xappConn1.SendRESTSubsDelReq(t, &restSubId) // E2t: Receive 1st SubsDelReq delreq, delmsg := e2termConn1.RecvSubsDelReq(t) mainCtrl.MakeTransactionNil(t, e2SubsId) // No transaction exist for this response which will result resending original request e2termConn1.SendSubsDelResp(t, delreq, delmsg) // E2t: Receive 2nd SubsDelReq delreq, delmsg = e2termConn1.RecvSubsDelReq(t) // Subscription does not exist in in E2 Node. e2termConn1.SendSubsDelFail(t, delreq, delmsg) // Wait that subs is cleaned mainCtrl.wait_subs_clean(t, e2SubsId, 10) xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) } //----------------------------------------------------------------------------- // TestRESTUnpackSubscriptionDeleteFailureDecodeFail // // stub stub // +-------+ +---------+ +---------+ // | xapp | | submgr | | e2term | // +-------+ +---------+ +---------+ // | | | // | [SUBS CREATE] | // | | | // | | | // | RESTSubDelReq | | // |---------------->| | // | | | // | RESTSubDelResp | | // |<----------------| | // | | | // | | SubDelReq | // | |------------->| // | | | // | | SubDelFail | ASN.1 decode fails // | |<-------------| // | | | // | | SubDelReq | // | |------------->| // | | | // | | SubDelFail | Subscription does exist any more // | |<-------------| // //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) { xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail") // Req var params *teststube2ap.RESTSubsReqParams = nil restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) // Del xappConn1.SendRESTSubsDelReq(t, &restSubId) // E2t: Receive 1st SubsDelReq delreq, delmsg := e2termConn1.RecvSubsDelReq(t) // Decode of this response fails which will result resending original request e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE) // E2t: Receive 2nd SubsDelReq and send SubsDelResp delreq, delmsg = e2termConn1.RecvSubsDelReq(t) // Subscription does not exist in in E2 Node. e2termConn1.SendSubsDelFail(t, delreq, delmsg) // Wait that subs is cleaned mainCtrl.wait_subs_clean(t, e2SubsId, 10) xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) } //----------------------------------------------------------------------------- // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId // // stub stub // +-------+ +---------+ +---------+ // | xapp | | submgr | | e2term | // +-------+ +---------+ +---------+ // | | | // | [SUBS CREATE] | // | | | // | | | // | RESTSubDelReq | | // |---------------->| | // | | | // | RESTSubDelResp | | // |<----------------| | // | | | // | | SubDelReq | // | |------------->| // | | | // | | SubDelFail | Unknown instanceId // | |<-------------| // | | | // | | SubDelReq | // | |------------->| // | | | // | | SubDelFail | Subscription does exist any more // | |<-------------| // //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) { xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId") // Req var params *teststube2ap.RESTSubsReqParams = nil restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) // Del xappConn1.SendRESTSubsDelReq(t, &restSubId) // E2t: Receive 1st SubsDelReq delreq, delmsg := e2termConn1.RecvSubsDelReq(t) // Unknown instanceId in this response which will result resending original request delreq.RequestId.InstanceId = 0 e2termConn1.SendSubsDelFail(t, delreq, delmsg) // E2t: Receive 2nd SubsDelReq delreq, delmsg = e2termConn1.RecvSubsDelReq(t) // Subscription does not exist in in E2 Node. e2termConn1.SendSubsDelFail(t, delreq, delmsg) // Wait that subs is cleaned mainCtrl.wait_subs_clean(t, e2SubsId, 10) xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) } //----------------------------------------------------------------------------- // TestRESTUnpackSubscriptionDeleteFailureNoTransaction // // stub stub // +-------+ +---------+ +---------+ // | xapp | | submgr | | e2term | // +-------+ +---------+ +---------+ // | | | // | [SUBS CREATE] | // | | | // | | | // | RESTSubDelReq | | // |---------------->| | // | | | // | RESTSubDelResp | | // |<----------------| | // | | | // | | SubDelReq | // | |------------->| // | | | // | | SubDelFail | No transaction for the response // | |<-------------| // | | | // | | SubDelReq | // | |------------->| // | | | // | | SubDelFail | Subscription does exist any more // | |<-------------| // //----------------------------------------------------------------------------- func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) { xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction") // Req var params *teststube2ap.RESTSubsReqParams = nil restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params) // Del xappConn1.SendRESTSubsDelReq(t, &restSubId) // E2t: Receive 1st SubsDelReq delreq, delmsg := e2termConn1.RecvSubsDelReq(t) mainCtrl.MakeTransactionNil(t, e2SubsId) // No transaction exist for this response which will result resending original request e2termConn1.SendSubsDelFail(t, delreq, delmsg) // E2t: Receive 2nd SubsDelReq delreq, delmsg = e2termConn1.RecvSubsDelReq(t) // Subscription does not exist in in E2 Node. e2termConn1.SendSubsDelFail(t, delreq, delmsg) // Wait that subs is cleaned mainCtrl.wait_subs_clean(t, e2SubsId, 10) xappConn1.TestMsgChanEmpty(t) e2termConn1.TestMsgChanEmpty(t) mainCtrl.wait_registry_empty(t, 10) } //----------------------------------------------------------------------------- // TestRESTSubReqFailAsn1PackSubReqError // // stub stub // +-------+ +---------+ +---------+ // | xapp | | submgr | | e2term | // +-------+ +---------+ +---------+ // | | | // | RESTSubReq | | // |---------------->| | // | | | // | RESTSubResp | | // |<----------------| | // | | | // | ASN.1 encode fails | // | | | // | | SubDelReq | // | |------------->| // | | | // | | SubDelFail | // | |<-------------| // | | | // | RESTNotif | | // | unsuccess | | // |<----------------| | // | | | // | [SUBS DELETE] | // | | | // //----------------------------------------------------------------------------- func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) { mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{ Counter{cRestSubReqFromXapp, 1}, Counter{cRestSubRespToXapp, 1}, Counter{cSubDelReqToE2, 1}, Counter{cSubDelFailFromE2, 1}, Counter{cRestSubFailNotifToXapp, 1}, }) subReqCount := 1 var params *teststube2ap.RESTSubsReqParams = nil params = xappConn1.GetRESTSubsReqReportParams(subReqCount) e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false) // Req restSubId := xappConn1.SendRESTSubsReq(t, params) xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId) // E2t: Receive SubsDelReq delreq, delmsg := e2termConn1.RecvSubsDelReq(t) xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail") // Subscription does not exist in in E2 Node. e2termConn1.SendSubsDelFail(t, delreq, delmsg) e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId) e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true) // Wait that subs is cleaned waitSubsCleanup(t, e2SubsId, 10) mainCtrl.VerifyCounterValues(t) } //////////////////////////////////////////////////////////////////////////////////// // Services for UT cases //////////////////////////////////////////////////////////////////////////////////// const subReqCount int = 1 const 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.Info("Send REST subscriber request for subscriberId : %v", restSubId) crereq1, cremsg1 := toE2termConn.RecvSubsReq(t) fromXappConn.ExpectRESTNotification(t, restSubId) toE2termConn.SendSubsResp(t, crereq1, cremsg1) e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId) xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId) 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.Info("Send REST subscriber request for subscriberId : %v", restSubId) e2SubsId := xappConn2.WaitRESTNotification(t, restSubId) xapp.Logger.Info("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.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId) crereq1, cremsg1 := e2termConn1.RecvSubsReq(t) xappConn1.ExpectRESTNotification(t, restSubId) e2termConn1.SendSubsResp(t, crereq1, cremsg1) e2SubsId := xappConn1.WaitRESTNotification(t, restSubId) xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId) 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.Info("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.Info("TEST: %d ===================================== BEGIN CRE ============================================", i+1) crereq, cremsg := toE2termConn.RecvSubsReq(t) fromXappConn.ExpectRESTNotification(t, restSubId) toE2termConn.SendSubsResp(t, crereq, cremsg) instanceId := fromXappConn.WaitRESTNotification(t, restSubId) e2SubsId = append(e2SubsId, instanceId) xapp.Logger.Info("TEST: %v", e2SubsId) xapp.Logger.Info("TEST: %d ===================================== END CRE ============================================", i+1) <-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.Info("TEST: %d ===================================== BEGIN DEL ============================================", i+1) delreq, delmsg := toE2termConn.RecvSubsDelReq(t) toE2termConn.SendSubsDelResp(t, delreq, delmsg) <-time.After(1 * time.Second) xapp.Logger.Info("TEST: %d ===================================== END DEL ============================================", i+1) <-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) } }