// like this:git log
// SetPackerIf(e2ap_wrapper.NewAsn1E2APPacker())
+ mainCtrl.InitAllCounterMap()
SetPackerIf(e2ap_wrapper.NewUtAsn1E2APPacker())
mainCtrl.c.restDuplicateCtrl.Init()
mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
+ //os.Exit(0)
}
//-----------------------------------------------------------------------------
// Wait that subs is cleaned
waitSubsCleanup(t, e2SubsId, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
e2termConn1.TestMsgChanEmpty(t)
mainCtrl.wait_registry_empty(t, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
// Wait that subs is cleaned
waitSubsCleanup(t, e2SubsId, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
waitSubsCleanup(t, e2SubsId, 10)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, true)
waitSubsCleanup(t, e2SubsId, 10)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, true)
waitSubsCleanup(t, e2SubsId, 10)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
// Init counter check
mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
Counter{cSubReqFromXapp, 2},
+ Counter{cMergedSubscriptions, 1},
Counter{cSubReqToE2, 1},
Counter{cSubRespFromE2, 1},
Counter{cSubRespToXapp, 2},
Counter{cSubDelReqToE2, 1},
Counter{cSubDelRespFromE2, 1},
Counter{cSubDelRespToXapp, 2},
+ Counter{cUnmergedSubscriptions, 1},
})
//Req1
mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
Counter{cSubReqFromXapp, 1},
Counter{cSubReqToE2, 1},
+ Counter{cSubReqTimerExpiry, 1},
Counter{cSubReReqToE2, 1},
Counter{cSubRespFromE2, 1},
Counter{cSubRespToXapp, 1},
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.SimulateRestart(t)
xapp.Logger.Debug("mainCtrl.SimulateRestart done")
+ // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
+ // That needs to be completed before successful subscription query is possible
+ <-time.After(time.Second * 1)
+
// Check that subscription is restored correctly after restart
resp, _ = xapp.Subscription.QuerySubscriptions()
assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
// Check subscription
- resp, _ := xapp.Subscription.QuerySubscriptions() ////////////////////////////////
+ resp, _ := xapp.Subscription.QuerySubscriptions()
assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
mainCtrl.SimulateRestart(t)
xapp.Logger.Debug("mainCtrl.SimulateRestart done")
+ // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
+ // That needs to be completed before successful subscription query is possible
+ <-time.After(time.Second * 1)
+
// Check that subscription is restored correctly after restart
resp, _ = xapp.Subscription.QuerySubscriptions()
assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
mainCtrl.SimulateRestart(t)
xapp.Logger.Debug("mainCtrl.SimulateRestart done")
+ // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
+ // Submgr need be ready before successful subscription deletion is possible
+ <-time.After(time.Second * 1)
+
//Del2
deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
mainCtrl.wait_subs_clean(t, newSubsId, 10)
waitSubsCleanup(t, e2SubsId, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
Counter{cRestSubNotifToXapp, 1},
Counter{cRestSubFailNotifToXapp, 1},
Counter{cRouteCreateUpdateFail, 1},
- Counter{cRestSubDelReqFromXapp, 1},
+ Counter{cRestSubDelReqFromXapp, 2},
Counter{cSubDelReqToE2, 1},
Counter{cSubDelRespFromE2, 1},
- Counter{cRestSubDelRespToXapp, 1},
+ Counter{cRestSubDelRespToXapp, 2},
})
var params *teststube2ap.RESTSubsReqParams = nil
xapp.Logger.Debug("Send REST subscriber request for second subscriber : %v", restSubId2)
xappConn2.ExpectRESTNotificationNok(t, restSubId2, "allFail")
waiter.WaitResult(t)
- // e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) - TOD: missing delete
xappConn2.WaitRESTNotification(t, restSubId2)
queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
+ xappConn2.SendRESTSubsDelReq(t, &restSubId2)
mainCtrl.wait_subs_clean(t, newSubsId, 10)
//Wait that subs is cleaned
waitSubsCleanup(t, e2SubsId, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
waiter.WaitResult(t)
waitSubsCleanup(t, e2SubsId, 10)
-
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
Counter{cRestSubReqFromXapp, 2},
+ Counter{cMergedSubscriptions, 1},
Counter{cRestSubRespToXapp, 2},
Counter{cSubReqToE2, 1},
Counter{cSubRespFromE2, 1},
Counter{cSubDelReqToE2, 1},
Counter{cSubDelRespFromE2, 1},
Counter{cRestSubDelRespToXapp, 2},
+ Counter{cUnmergedSubscriptions, 1},
})
var params *teststube2ap.RESTSubsReqParams = nil
waitSubsCleanup(t, e2SubsId2, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
// Subs Create
const subReqCount int = 1
- // In order to force both XAPP's to create their own subscriptions, force rtmgr to block a while so that 2nd create
- // gets into execution before the rtmgrg responds for the first one.
- waiter := rtmgrHttp.AllocNextSleep(10, true)
params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
- restSubId1 := xappConn1.SendRESTSubsReq(t, params)
- xappConn2.SendRESTSubsReq(t, params)
+ restSubId := xappConn1.SendRESTSubsReq(t, params)
- waiter.WaitResult(t)
+ xappConn1.SendRESTSubsReq(t, params)
+ <-time.After(time.Second * 1)
- xappConn1.WaitListedRestNotifications(t, []string{restSubId1})
+ xappConn1.WaitListedRestNotifications(t, []string{restSubId})
// Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
- // the order is not significant he6re.
+ // the order is not significant here.
crereq, cremsg := e2termConn1.RecvSubsReq(t)
e2termConn1.SendSubsResp(t, crereq, cremsg)
- e2SubsIdA := <-xappConn1.ListedRESTNotifications
- xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
+ e2SubsId := <-xappConn1.ListedRESTNotifications
+
+ xapp.Logger.Debug("TEST: XAPP notification received e2SubsId=%v", e2SubsId)
// Del1
- xappConn1.SendRESTSubsDelReq(t, &restSubId1)
+ xappConn1.SendRESTSubsDelReq(t, &restSubId)
delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
- mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId}, 10)
+ mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsId.E2SubsId}, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
Counter{cRestSubReqFromXapp, 3},
+ Counter{cDuplicateE2SubReq, 2},
Counter{cRestSubRespToXapp, 3},
Counter{cSubReqToE2, 1},
Counter{cSubRespFromE2, 1},
deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
waitSubsCleanup(t, e2SubsId, 10)
-
- //Wait that subs is cleaned
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
Counter{cRestSubReqFromXapp, 3},
+ Counter{cDuplicateE2SubReq, 2},
Counter{cRestSubRespToXapp, 3},
Counter{cSubReqToE2, 1},
Counter{cSubRespFromE2, 1},
deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
waitSubsCleanup(t, e2SubsId, 10)
-
- //Wait that subs is cleaned
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
Counter{cRestSubReqFromXapp, 3},
+ Counter{cDuplicateE2SubReq, 2},
Counter{cRestSubRespToXapp, 3},
Counter{cSubReqToE2, 2},
Counter{cSubRespFromE2, 2},
sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
waitSubsCleanup(t, e2SubsId, 10)
-
- //Wait that subs is cleaned
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
Counter{cRestSubReqFromXapp, 3},
+ Counter{cDuplicateE2SubReq, 2},
Counter{cRestSubRespToXapp, 3},
Counter{cSubReqToE2, 2},
Counter{cSubRespFromE2, 2},
sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
waitSubsCleanup(t, e2SubsId, 10)
-
- //Wait that subs is cleaned
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
Counter{cRestSubReqFromXapp, 3},
+ Counter{cDuplicateE2SubReq, 1},
Counter{cRestSubRespToXapp, 3},
Counter{cSubReqToE2, 3},
Counter{cSubRespFromE2, 3},
deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
waitSubsCleanup(t, e2SubsId, 10)
-
- //Wait that subs is cleaned
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTSubDelReqRetransmission(t *testing.T) {
Counter{cRestSubDelReqFromXapp, 2},
Counter{cSubDelReqToE2, 1},
Counter{cSubDelRespFromE2, 1},
- Counter{cRestSubDelRespToXapp, 1},
+ Counter{cRestSubDelRespToXapp, 2},
})
var params *teststube2ap.RESTSubsReqParams = nil
e2termConn1.SendSubsDelResp(t, delreq, delmsg)
waitSubsCleanup(t, e2SubsId, 10)
-
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
Counter{cSubRespFromE2, 1},
Counter{cRestSubNotifToXapp, 1},
Counter{cRestSubDelReqFromXapp, 2},
+ Counter{cRestSubDelFailToXapp, 1},
Counter{cSubDelReqToE2, 1},
Counter{cSubDelRespFromE2, 1},
Counter{cRestSubDelRespToXapp, 1},
// Wait that subs is cleaned
waitSubsCleanup(t, e2SubsId, 10)
mainCtrl.VerifyCounterValues(t)
-
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTSubDelReqCollision(t *testing.T) {
waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
mainCtrl.VerifyCounterValues(t)
-
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTSameSubsDiffRan(t *testing.T) {
waitSubsCleanup(t, e2SubsId2, 10)
mainCtrl.VerifyCounterValues(t)
-
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTSubReqRetryInSubmgr(t *testing.T) {
Counter{cRestSubReqFromXapp, 1},
Counter{cRestSubRespToXapp, 1},
Counter{cSubReqToE2, 1},
+ Counter{cSubReqTimerExpiry, 1},
Counter{cSubReReqToE2, 1},
Counter{cSubRespFromE2, 1},
Counter{cRestSubNotifToXapp, 1},
waitSubsCleanup(t, e2SubsId, 10)
mainCtrl.VerifyCounterValues(t)
-
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
Counter{cSubReqToE2, 1},
Counter{cSubReReqToE2, 1},
Counter{cSubReqTimerExpiry, 2},
+ Counter{cRestSubFailNotifToXapp, 1},
Counter{cSubDelReqToE2, 1},
Counter{cSubDelRespFromE2, 1},
+ Counter{cRestSubDelReqFromXapp, 1},
+ Counter{cRestSubDelRespToXapp, 1},
})
params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
e2termConn1.SendSubsDelResp(t, delreq, delmsg)
xappConn1.WaitRESTNotification(t, restSubId)
+ xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
// Wait that subs is cleaned
waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
-
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
Counter{cSubReqToE2, 1},
Counter{cSubReReqToE2, 1},
Counter{cSubReqTimerExpiry, 2},
+ Counter{cSubDelReReqToE2, 1},
+ Counter{cRestSubFailNotifToXapp, 1},
Counter{cSubDelReqToE2, 1},
Counter{cSubDelReqTimerExpiry, 2},
+ Counter{cRestSubDelReqFromXapp, 1},
+ Counter{cRestSubDelRespToXapp, 1},
})
params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
- waitSubsCleanup(t, e2SubsId, 10)
+ xappConn1.SendRESTSubsDelReq(t, &restSubId)
+ waitSubsCleanup(t, e2SubsId, 10)
mainCtrl.VerifyCounterValues(t)
-
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
Counter{cSubReqToE2, 1},
Counter{cSubReReqToE2, 1},
Counter{cSubReqTimerExpiry, 2},
+ Counter{cRestSubFailNotifToXapp, 1},
Counter{cSubDelReqToE2, 1},
Counter{cSubDelReReqToE2, 1},
Counter{cSubDelReqTimerExpiry, 2},
+ Counter{cRestSubDelReqFromXapp, 1},
+ Counter{cRestSubDelRespToXapp, 1},
})
params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
- waitSubsCleanup(t, e2SubsId, 10)
+ xappConn1.SendRESTSubsDelReq(t, &restSubId)
+ waitSubsCleanup(t, e2SubsId, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
Counter{cSubFailFromE2, 1},
Counter{cRestSubFailNotifToXapp, 1},
Counter{cRestSubDelReqFromXapp, 1},
+ Counter{cRestSubDelRespToXapp, 1},
})
const subReqCount int = 1
waitSubsCleanup(t, e2SubsId, 10)
mainCtrl.VerifyCounterValues(t)
-
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
Counter{cRestSubNotifToXapp, 1},
Counter{cRestSubDelReqFromXapp, 1},
Counter{cSubDelReqToE2, 1},
+ Counter{cSubDelReqTimerExpiry, 1},
Counter{cSubDelReReqToE2, 1},
Counter{cSubDelRespFromE2, 1},
Counter{cRestSubDelRespToXapp, 1},
waitSubsCleanup(t, e2SubsId, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
Counter{cRestSubNotifToXapp, 1},
Counter{cRestSubDelReqFromXapp, 1},
Counter{cSubDelReqToE2, 1},
+ Counter{cSubDelReqTimerExpiry, 1},
Counter{cSubDelReReqToE2, 1},
Counter{cSubDelRespFromE2, 1},
Counter{cRestSubDelRespToXapp, 1},
waitSubsCleanup(t, e2SubsId, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
waitSubsCleanup(t, e2SubsId, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
//Wait that subs is cleaned
waitSubsCleanup(t, e2SubsId2, 10)
-
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
waitSubsCleanup(t, e2SubsId2, 10)
-
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
// | RESTSubReq2 | |
// |------------------------------>| |
// | | | |
-// | RESTSubDelResp2 | |
+// | RESTSubResp2 | |
// |<------------------------------| |
// | | | SubReq1 |
// | | |------------->|
mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
Counter{cRestSubReqFromXapp, 2},
+ Counter{cMergedSubscriptions, 1},
Counter{cRestSubRespToXapp, 2},
Counter{cSubReqToE2, 1},
+ Counter{cSubReqTimerExpiry, 2},
+ Counter{cSubReReqToE2, 1},
Counter{cRestSubFailNotifToXapp, 2},
+ Counter{cUnmergedSubscriptions, 1},
Counter{cRestSubDelReqFromXapp, 2},
Counter{cSubDelReqToE2, 1},
Counter{cSubDelRespFromE2, 1},
Counter{cRestSubDelRespToXapp, 2},
})
-
const subReqCount int = 1
// Req1
//Wait that subs is cleaned
waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
-
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
Counter{cRestSubReqFromXapp, 2},
+ Counter{cMergedSubscriptions, 1},
Counter{cRestSubRespToXapp, 2},
Counter{cSubReqToE2, 1},
Counter{cSubFailFromE2, 1},
Counter{cRestSubFailNotifToXapp, 2},
+ Counter{cUnmergedSubscriptions, 1},
Counter{cRestSubDelReqFromXapp, 2},
Counter{cRestSubDelRespToXapp, 2},
})
//Wait that subs is cleaned
waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
-
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
// Wait that subs is cleaned
waitSubsCleanup(t, e2SubsId, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
// Wait that subs is cleaned
waitSubsCleanup(t, e2SubsId, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
// Wait that subs is cleaned
waitSubsCleanup(t, e2SubsId, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
waitSubsCleanup(t, e2SubsId2, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
// Wait that subs is cleaned
waitSubsCleanup(t, e2SubsId, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
// | RESTSubReq | |
// |------------->| |
// | | |
+// | RESTSubResp | |
+// |<-------------| |
// | | SubReq |
// | |------------->|
// | | |
// | | SubDelResp |
// | |<-------------|
// | | |
+// | RESTNotif | |
+// | unsuccess | |
+// |<-------------| |
+// | | |
+// | RESTSubDelReq| |
+// |------------->| |
+// | | |
+// |RESTSubDelResp| |
+// |<-------------| |
//
//-----------------------------------------------------------------------------
func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
Counter{cSubDelReqFromXapp, 1},
Counter{cSubDelReqToE2, 1},
Counter{cSubDelRespFromE2, 1},
+ Counter{cRestSubDelReqFromXapp, 1},
+ Counter{cRestSubDelRespToXapp, 1},
})
const subReqCount int = 1
- // Remove possible existing subscription
- mainCtrl.removeExistingSubscriptions(t)
-
params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
//Req
mainCtrl.SimulateRestart(t)
xapp.Logger.Debug("mainCtrl.SimulateRestart done")
- //Del
+ // Deleletion of uncompleted subscription
delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
e2termConn1.SendSubsDelResp(t, delreq, delmsg)
+ //Del
+ xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
xappConn1.TestMsgChanEmpty(t)
- xappConn2.TestMsgChanEmpty(t)
e2termConn1.TestMsgChanEmpty(t)
mainCtrl.wait_registry_empty(t, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
Counter{cRestSubNotifToXapp, 1},
Counter{cRestSubDelReqFromXapp, 1},
Counter{cSubDelReqToE2, 1},
+ Counter{cSubDelRespFromE2, 1},
Counter{cRestSubDelRespToXapp, 1},
})
- // Remove possible existing subscription
- mainCtrl.removeExistingSubscriptions(t)
-
- var params *teststube2ap.RESTSubsReqParams = nil
-
// Create subscription
+ var params *teststube2ap.RESTSubsReqParams = nil
restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
mainCtrl.SimulateRestart(t)
xapp.Logger.Debug("mainCtrl.SimulateRestart done")
+ // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
+ // That needs to be completed before successful subscription query is possible
+ <-time.After(time.Second * 1)
+
// Check subscription
queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
waitSubsCleanup(t, e2SubsId, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
// | | | |
//
//-----------------------------------------------------------------------------
-
func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
Counter{cRestSubDelRespToXapp, 2},
})
- // Remove possible existing subscription
- mainCtrl.removeExistingSubscriptions(t)
-
- var params *teststube2ap.RESTSubsReqParams = nil
-
// Create subscription 1
+ var params *teststube2ap.RESTSubsReqParams = nil
restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
xapp.Logger.Debug("Send REST subscriber request for subscriber 1 : %v", restSubId1)
queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
mainCtrl.SimulateRestart(t)
- xapp.Logger.Debug("mainCtrl.SimulateRestart done")
+ xapp.Logger.Debug("mainCtrl.SimulateRestart done 1")
+
+ // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
+ // That needs to be completed before successful subscription delete is possible
+ <-time.After(time.Second * 1)
// Delete subscription 1, and wait until it has removed the first endpoint
subepcnt := mainCtrl.get_subs_entrypoint_cnt(t, e2SubsId1)
xappConn1.SendRESTSubsDelReq(t, &restSubId1)
mainCtrl.wait_subs_entrypoint_cnt_change(t, e2SubsId1, subepcnt, 10)
+ // Above wait does not work correctly anymore as this delay makes this test case work
+ //<-time.After(time.Second * 1)
+
mainCtrl.SimulateRestart(t)
- xapp.Logger.Debug("mainCtrl.SimulateRestart done")
+ xapp.Logger.Debug("mainCtrl.SimulateRestart done 2")
+
+ // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
+ // That needs to be completed before successful subscription query is possible
+ <-time.After(time.Second * 1)
+
queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
// Delete subscription 2
waitSubsCleanup(t, e2SubsId2, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
xappConn1.TestMsgChanEmpty(t)
e2termConn1.TestMsgChanEmpty(t)
mainCtrl.wait_registry_empty(t, 10)
+ mainCtrl.VerifyAllClean(t)
}
/*
-func TestRESTPolicySubReqAndSubDelOk(t *testing.T) {
+func TestRESTPolicySubReqAndSubDelOk(t *testing.T) { was in comments already
CaseBegin("TestRESTPolicySubReqAndSubDelOk")
subReqCount := 2
xappConn1.TestMsgChanEmpty(t)
e2termConn1.TestMsgChanEmpty(t)
mainCtrl.wait_registry_empty(t, 10)
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
mainCtrl.wait_registry_empty(t, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
mainCtrl.wait_registry_empty(t, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
mainCtrl.wait_registry_empty(t, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
mainCtrl.wait_registry_empty(t, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
mainCtrl.wait_registry_empty(t, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
waitSubsCleanup(t, e2SubsId2, 10)
mainCtrl.VerifyCounterValues(t)
-
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
waitSubsCleanup(t, e2SubsId2, 10)
mainCtrl.VerifyCounterValues(t)
-
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
waitSubsCleanup(t, e2SubsId2, 10)
mainCtrl.VerifyCounterValues(t)
-
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTSubReqDiffActionType(t *testing.T) {
waitSubsCleanup(t, e2SubsId2, 10)
mainCtrl.VerifyCounterValues(t)
-
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
waitSubsCleanup(t, e2SubsId2, 10)
mainCtrl.VerifyCounterValues(t)
-
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
waitSubsCleanup(t, e2SubsId2, 10)
mainCtrl.VerifyCounterValues(t)
-
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
waitSubsCleanup(t, e2SubsId2, 10)
mainCtrl.VerifyCounterValues(t)
-
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
waitSubsCleanup(t, e2SubsId2, 10)
mainCtrl.VerifyCounterValues(t)
-
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
instanceId := xappConn1.WaitRESTNotification(t, restSubId)
xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
+ xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
// Wait that subs is cleaned
mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
xappConn1.TestMsgChanEmpty(t)
e2termConn1.TestMsgChanEmpty(t)
mainCtrl.wait_registry_empty(t, 10)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
instanceId := xappConn1.WaitRESTNotification(t, restSubId)
xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
+ xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
// Wait that subs is cleaned
mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
xappConn1.TestMsgChanEmpty(t)
e2termConn1.TestMsgChanEmpty(t)
mainCtrl.wait_registry_empty(t, 10)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
instanceId := xappConn1.WaitRESTNotification(t, restSubId)
xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
+ xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
// Wait that subs is cleaned
mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
xappConn1.TestMsgChanEmpty(t)
e2termConn1.TestMsgChanEmpty(t)
mainCtrl.wait_registry_empty(t, 10)
-
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
instanceId := xappConn1.WaitRESTNotification(t, restSubId)
xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
+ xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
// Wait that subs is cleaned
mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
xappConn1.TestMsgChanEmpty(t)
e2termConn1.TestMsgChanEmpty(t)
mainCtrl.wait_registry_empty(t, 10)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
instanceId := xappConn1.WaitRESTNotification(t, restSubId)
xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
+ xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
// Wait that subs is cleaned
mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
xappConn1.TestMsgChanEmpty(t)
e2termConn1.TestMsgChanEmpty(t)
mainCtrl.wait_registry_empty(t, 10)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
instanceId := xappConn1.WaitRESTNotification(t, restSubId)
xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
+ xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
// Wait that subs is cleaned
mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
xappConn1.TestMsgChanEmpty(t)
e2termConn1.TestMsgChanEmpty(t)
mainCtrl.wait_registry_empty(t, 10)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
xappConn1.TestMsgChanEmpty(t)
e2termConn1.TestMsgChanEmpty(t)
mainCtrl.wait_registry_empty(t, 10)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
xappConn1.TestMsgChanEmpty(t)
e2termConn1.TestMsgChanEmpty(t)
mainCtrl.wait_registry_empty(t, 10)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
xappConn1.TestMsgChanEmpty(t)
e2termConn1.TestMsgChanEmpty(t)
mainCtrl.wait_registry_empty(t, 10)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
xappConn1.TestMsgChanEmpty(t)
e2termConn1.TestMsgChanEmpty(t)
mainCtrl.wait_registry_empty(t, 10)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
xappConn1.TestMsgChanEmpty(t)
e2termConn1.TestMsgChanEmpty(t)
mainCtrl.wait_registry_empty(t, 10)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
xappConn1.TestMsgChanEmpty(t)
e2termConn1.TestMsgChanEmpty(t)
mainCtrl.wait_registry_empty(t, 10)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
Counter{cRestSubReqFromXapp, 1},
Counter{cRestSubRespToXapp, 1},
Counter{cRestSubFailNotifToXapp, 1},
+ Counter{cRestSubDelReqFromXapp, 1},
+ Counter{cRestSubDelRespToXapp, 1},
})
const subReqCount int = 1
xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
+
+ xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
// Wait that subs is cleaned
waitSubsCleanup(t, e2SubsId, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
Counter{cRestSubReqFromXapp, 2},
Counter{cRestSubRespToXapp, 2},
Counter{cSubReqToE2, 2},
+ Counter{cSubReqTimerExpiry, 1},
Counter{cSubRespFromE2, 1},
Counter{cRestSubNotifToXapp, 1},
Counter{cRestSubFailNotifToXapp, 1},
waitSubsCleanup(t, e2SubsId, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
//-----------------------------------------------------------------------------
Counter{cSubReqToE2, 2},
Counter{cSubRespFromE2, 1},
Counter{cRestSubNotifToXapp, 1},
- Counter{cRestSubNotifToXapp, 1},
Counter{cRestSubDelReqFromXapp, 1},
Counter{cSubDelReqToE2, 1},
+ Counter{cSubDelRespFromE2, 1},
Counter{cRestSubDelRespToXapp, 1},
})
- // Remove possible existing subscription
- mainCtrl.removeExistingSubscriptions(t)
-
const e2Timeout int64 = 1
const e2RetryCount int64 = 0
const routingNeeded bool = false
mainCtrl.SimulateRestart(t)
xapp.Logger.Debug("mainCtrl.SimulateRestart done")
+ // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
+ // That needs to be completed before successful subscription query is possible
+ <-time.After(time.Second * 1)
+
// Check subscription
queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
- xapp.Logger.Debug("Here 1")
- //<-time.After(3 * time.Second)
- xapp.Logger.Debug("Here 2")
-
// Delete subscription
xappConn1.SendRESTSubsDelReq(t, &restSubId)
delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
waitSubsCleanup(t, e2SubsId, 10)
mainCtrl.VerifyCounterValues(t)
+ mainCtrl.VerifyAllClean(t)
}
////////////////////////////////////////////////////////////////////////////////////
func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
resp, _ := xapp.Subscription.QuerySubscriptions()
- assert.Equal(t, resp[0].SubscriptionID, e2SubsId)
- assert.Equal(t, resp[0].Meid, meid)
- assert.Equal(t, resp[0].ClientEndpoint, endpoint)
+ assert.Equal(t, e2SubsId, resp[0].SubscriptionID)
+ assert.Equal(t, meid, resp[0].Meid)
+ assert.Equal(t, endpoint, resp[0].ClientEndpoint)
}
func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {