Code Review / ric-plt / submgr.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
Merge "Fix for DB read after VM restart and REST subscription query aded"
[ric-plt/submgr.git] / pkg / control / ut_messaging_test.go
diff --git a/pkg/control/ut_messaging_test.go b/pkg/control/ut_messaging_test.go
index 5e7d5a7..bc1b6d3 100644 (file)
--- a/pkg/control/ut_messaging_test.go
+++ b/pkg/control/ut_messaging_test.go
@@ -20,6 +20,7 @@
 package control
 
 import (
+       "strings"
        "testing"
        "time"
 
@@ -37,6 +38,9 @@ func TestSuiteSetup(t *testing.T) {
        // SetPackerIf(e2ap_wrapper.NewAsn1E2APPacker())
 
        SetPackerIf(e2ap_wrapper.NewUtAsn1E2APPacker())
+
+       restDuplicateCtrl.Init()
+
 }
 
 //-----------------------------------------------------------------------------
@@ -2366,6 +2370,11 @@ func TestPostEmptyDb(t *testing.T) {
        mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/emptydb")
 }
 
+func TestGetRestSubscriptions(t *testing.T) {
+
+       mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/restsubscriptions")
+}
+
 //-----------------------------------------------------------------------------
 // TestRESTSubReqAndRouteNok
 //
@@ -2401,11 +2410,12 @@ func TestRESTSubReqAndRouteNok(t *testing.T) {
        CaseBegin("TestRESTSubReqAndRouteNok")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cRouteCreateFail, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubFailNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        const subReqCount int = 1
@@ -2416,7 +2426,7 @@ func TestRESTSubReqAndRouteNok(t *testing.T) {
        // Req
        params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
-       xappConn1.ExpectRESTNotification(t, restSubId)
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "failAll")
        waiter.WaitResult(t)
 
        e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
@@ -2436,15 +2446,17 @@ func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
 
        //Init counter check
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 2},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubFailNotifToXapp, 1},
                Counter{cRouteCreateUpdateFail, 1},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        var params *teststube2ap.RESTSubsReqParams = nil
@@ -2461,7 +2473,7 @@ func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
        params.SetMeid("RAN_NAME_1")
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
        xapp.Logger.Info("Send REST subscriber request for second subscriber : %v", restSubId2)
-       xappConn2.ExpectRESTNotification(t, restSubId2)
+       xappConn2.ExpectRESTNotificationNok(t, restSubId2, "allFail")
        waiter.WaitResult(t)
        // e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) - TOD: missing delete
        xappConn2.WaitRESTNotification(t, restSubId2)
@@ -2482,15 +2494,16 @@ func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
 
        // Init counter check
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cRouteDeleteFail, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        var params *teststube2ap.RESTSubsReqParams = nil
@@ -2515,15 +2528,16 @@ func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
        CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cRouteDeleteUpdateFail, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        var params *teststube2ap.RESTSubsReqParams = nil
@@ -2570,19 +2584,13 @@ func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
 //     | RESTSubReq2     |              |
 //     | (retrans)       |              |
 //     |---------------->|              |
-//     |                 |              |
-//     |                 | SubReq2      |
-//     |                 |------------->|
-//     |    RESTSubResp2 |              |
+//     | RESTSubResp(201)|              |
 //     |<----------------|              |
+//     |                 |              |
 //     |                 |     SubResp1 |
 //     |                 |<-------------|
 //     |      RESTNotif1 |              |
 //     |<----------------|              |
-//     |                 |     SubResp1 |
-//     |                 |<-------------|
-//     |      RESTNotif2 |              |
-//     |<----------------|              |
 //     |                 |              |
 //     |            [SUBS DELETE]       |
 //     |                 |              |
@@ -2593,59 +2601,596 @@ func TestRESTSubReqRetransmission(t *testing.T) {
        CaseBegin("TestRESTSubReqRetransmission")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
+               Counter{cSubReqToE2, 1},
+               Counter{cSubRespFromE2, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelRespFromE2, 1},
+               Counter{cRestSubDelRespToXapp, 1},
+       })
+       // Retry/duplicate will get the same way as the first request.
+       // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
+       // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
+
+       // Subs Create
+       const subReqCount int = 1
+
+       // In order to force both XAPP's to create their own subscriptions, force rtmgr to block a while so that 2nd create
+       // gets into execution before the rtmgrg responds for the first one.
+       waiter := rtmgrHttp.AllocNextSleep(10, true)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+       restSubId1 := xappConn1.SendRESTSubsReq(t, params)
+       xappConn2.SendRESTSubsReq(t, params)
+
+       waiter.WaitResult(t)
+
+       xappConn1.WaitListedRestNotifications(t, []string{restSubId1})
+
+       // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
+       // the order is not significant he6re.
+       crereq, cremsg := e2termConn1.RecvSubsReq(t)
+       e2termConn1.SendSubsResp(t, crereq, cremsg)
+
+       e2SubsIdA := <-xappConn1.ListedRESTNotifications
+       xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
+
+       // Del1
+       xappConn1.SendRESTSubsDelReq(t, &restSubId1)
+       delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
+       e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
+
+       mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId}, 10)
+
+       mainCtrl.VerifyCounterValues(t)
+}
+
+//-----------------------------------------------------------------------------
+//   stub                             stub          stub
+// +-------+        +---------+    +---------+   +---------+
+// | xapp  |        | submgr  |    | e2term  |   |  rtmgr  |
+// +-------+        +---------+    +---------+   +---------+
+//     |                 |              |             |
+//     | RESTSubReq      |              |             |
+//     |---------------->|              |             |
+//     |     RESTSubResp |              |             |
+//     |<----------------|              |             |
+//     |                 | RouteCreate  |             |
+//     |                 |--------------------------->|
+//     |                 | RouteResponse|             |
+//     |                 |<---------------------------|  // The order of these events may vary
+//     |                 | SubReq       |             |
+//     |                 |------------->|             |  // The order of these events may vary
+//     |                 |      SubResp |             |
+//     |                 |<-------------|             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubReq      |              |             |
+//     | [RETRANS1]      |              |             |
+//     |---------------->|              |             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubReq      |              |             |
+//     | [RETRANS2]      |              |             |
+//     |---------------->|              |             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubDelReq   |              |             |
+//     |---------------->|              |             |
+//     |                 | SubDelReq    |             |
+//     |                 |------------->|             |
+//     |   RESTSubDelResp|              |             |
+//     |<----------------|              |             |
+//     |                 |   SubDelResp |             |
+//     |                 |<-------------|             |
+//     |                 |              |             |
+//
+//-----------------------------------------------------------------------------
+
+func TestRESTSubReqRetransmissionV2(t *testing.T) {
+       CaseBegin("TestRESTSubReqRetransmissionV2")
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 3},
+               Counter{cRestSubRespToXapp, 3},
+               Counter{cSubReqToE2, 1},
+               Counter{cSubRespFromE2, 1},
+               Counter{cRestSubNotifToXapp, 3},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelRespFromE2, 1},
+               Counter{cRestSubDelRespToXapp, 1},
+       })
+
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
+
+       queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
+
+       //1.st resend
+       restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
+
+       assert.Equal(t, restSubId_resend, restSubId)
+
+       <-time.After(100 * time.Millisecond)
+
+       //2.nd resend
+       restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
+
+       assert.Equal(t, restSubId_resend2, restSubId)
+
+       <-time.After(100 * time.Millisecond)
+
+       deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
+
+       waitSubsCleanup(t, e2SubsId, 10)
+
+       //Wait that subs is cleaned
+       mainCtrl.VerifyCounterValues(t)
+}
+
+//-----------------------------------------------------------------------------
+//   stub                             stub          stub
+// +-------+        +---------+    +---------+   +---------+
+// | xapp  |        | submgr  |    | e2term  |   |  rtmgr  |
+// +-------+        +---------+    +---------+   +---------+
+//     |                 |              |             |
+//     | RESTSubReq      |              |             |
+//     |---------------->|              |             |
+//     |     RESTSubResp |              |             |
+//     |<----------------|              |             |
+//     |                 | RouteCreate  |             |
+//     |                 |--------------------------->|
+//     |                 | RouteResponse|             |
+//     |                 |<---------------------------|  // The order of these events may vary
+//     |                 | SubReq       |             |
+//     |                 |------------->|             |  // The order of these events may vary
+//     |                 |      SubResp |             |
+//     |                 |<-------------|             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubReq      |              |             |
+//     | [RETRANS, with RESTsubsId]     |             |
+//     |---------------->|              |             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubReq      |              |             |
+//     | [RETRANS, without RESTsubsId]  |             |
+//     |---------------->|              |             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubDelReq   |              |             |
+//     |---------------->|              |             |
+//     |                 | SubDelReq    |             |
+//     |                 |------------->|             |
+//     |   RESTSubDelResp|              |             |
+//     |<----------------|              |             |
+//     |                 |   SubDelResp |             |
+//     |                 |<-------------|             |
+//     |                 |              |             |
+//
+//-----------------------------------------------------------------------------
+func TestRESTSubReqRetransmissionV3(t *testing.T) {
+       CaseBegin("TestRESTSubReqRetransmissionV3")
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 3},
+               Counter{cRestSubRespToXapp, 3},
+               Counter{cSubReqToE2, 1},
+               Counter{cSubRespFromE2, 1},
+               Counter{cRestSubNotifToXapp, 3},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelRespFromE2, 1},
+               Counter{cRestSubDelRespToXapp, 1},
+       })
+
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
+
+       queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
+
+       <-time.After(100 * time.Millisecond)
+
+       //1.st resend with subscription ID
+       params.SetSubscriptionID(&restSubId)
+       restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
+
+       assert.Equal(t, restSubId_resend, restSubId)
+
+       <-time.After(100 * time.Millisecond)
+
+       //2.nd resend without subscription ID (faking app restart)
+       params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
+       restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
+
+       assert.Equal(t, restSubId_resend2, restSubId)
+
+       <-time.After(100 * time.Millisecond)
+
+       deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
+
+       waitSubsCleanup(t, e2SubsId, 10)
+
+       //Wait that subs is cleaned
+       mainCtrl.VerifyCounterValues(t)
+}
+
+//-----------------------------------------------------------------------------
+//   stub                             stub          stub
+// +-------+        +---------+    +---------+   +---------+
+// | xapp  |        | submgr  |    | e2term  |   |  rtmgr  |
+// +-------+        +---------+    +---------+   +---------+
+//     |                 |              |             |
+//     | RESTSubReq      |              |             |
+//     |---------------->|              |             |
+//     |     RESTSubResp |              |             |
+//     |<----------------|              |             |
+//     |                 | RouteCreate  |             |
+//     |                 |--------------------------->|
+//     |                 | RouteResponse|             |
+//     |                 |<---------------------------|
+//     |                 | SubReq       |             |
+//     |                 |------------->|             |
+//     |                 |      SubResp |             |
+//     |                 |<-------------|             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubReq      |              |             |
+//     | [with RestSUbsId + one additional e2 subDetail]
+//     |---------------->|              |             |
+//     |      RESTNotif1 |              |             |
+//     | [for initial e2 subDetail]     |             |
+//     |<----------------|              |             |
+//     |                 | RouteCreate  |             |
+//     |                 |--------------------------->|
+//     |                 | RouteResponse|             |
+//     |                 |<---------------------------|
+//     |                 | SubReq       |             |
+//     |                 |------------->|             |
+//     |                 |      SubResp |             |
+//     |                 |<-------------|             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubReq      |              |             |
+//     | [with RESTsubsId initial request]            |
+//     |---------------->|              |             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubDelReq   |              |             |
+//     |---------------->|              |             |
+//     |   RESTSubDelResp|              |             |
+//     |<----------------|              |             |
+//     |                 | SubDelReq    |             |
+//     |                 |------------->|             |
+//     |                 |   SubDelResp |             |
+//     |                 |<-------------|             |
+//     |                 | SubDelReq    |             |
+//     |                 |------------->|             |
+//     |                 |   SubDelResp |             |
+//     |                 |<-------------|             |
+//     |                 |              |             |
+//
+//-----------------------------------------------------------------------------
+
+func TestRESTSubReqRetransmissionV4(t *testing.T) {
+       CaseBegin("TestRESTSubReqRetransmissionV4")
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 3},
+               Counter{cRestSubRespToXapp, 3},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 4},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 1},
        })
-       // 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
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
+
+       <-time.After(100 * time.Millisecond)
+
+       // Send modified  requst, this time with e2 subscriptions.
+       params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
+       params2.SetSubscriptionID(&restSubId)
+
+       xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
+       xappConn1.ExpectAnyNotification(t)
+       // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
+       restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
+       e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
+       assert.Equal(t, e2SubsId, e2SubsId1)
+
+       crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
+
+       xappConn1.DecrementRequestCount()
+       xappConn1.ExpectRESTNotification(t, restSubId_resend)
+       e2termConn1.SendSubsResp(t, crereq2, cremsg2)
+       e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
+       assert.NotEqual(t, e2SubsId2, 0)
+
+       <-time.After(100 * time.Millisecond)
+
+       xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
+       params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
+       params.SetSubscriptionID(&restSubId)
+       xappConn1.ExpectAnyNotification(t)
+       // Resend the original request again with only one e2 subscription (detail), this time with restsubsid
+       restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
+       assert.Equal(t, restSubId_resend, restSubId_resend2)
+
+       e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
+       assert.Equal(t, e2SubsId, e2SubsId1)
+
+       // Delete both e2 subscriptions
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+       e2SubsIds := []uint32{e2SubsId, e2SubsId2}
+       sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
+
+       waitSubsCleanup(t, e2SubsId, 10)
+
+       //Wait that subs is cleaned
+       mainCtrl.VerifyCounterValues(t)
+}
+
+//-----------------------------------------------------------------------------
+//   stub                             stub          stub
+// +-------+        +---------+    +---------+   +---------+
+// | xapp  |        | submgr  |    | e2term  |   |  rtmgr  |
+// +-------+        +---------+    +---------+   +---------+
+//     |                 |              |             |
+//     | RESTSubReq      |              |             |
+//     |---------------->|              |             |
+//     |     RESTSubResp |              |             |
+//     |<----------------|              |             |
+//     |                 | RouteCreate  |             |
+//     |                 |--------------------------->|
+//     |                 | RouteResponse|             |
+//     |                 |<---------------------------|
+//     |                 | SubReq       |             |
+//     |                 |------------->|             |
+//     |                 |      SubResp |             |
+//     |                 |<-------------|             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubReq      |              |             |
+//     | [with RestSUbsId + one additional e2 subDetail]
+//     |---------------->|              |             |
+//     |      RESTNotif1 |              |             |
+//     | [for initial e2 subDetail]     |             |
+//     |<----------------|              |             |
+//     |                 | RouteCreate  |             |
+//     |                 |--------------------------->|
+//     |                 | RouteResponse|             |
+//     |                 |<---------------------------|
+//     |                 | SubReq       |             |
+//     |                 |------------->|             |
+//     |                 |      SubResp |             |
+//     |                 |<-------------|             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubReq      |              |             |
+//     | [without RESTsubsId initial request]         |
+//     |---------------->|              |             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubDelReq   |              |             |
+//     |---------------->|              |             |
+//     |   RESTSubDelResp|              |             |
+//     |<----------------|              |             |
+//     |                 | SubDelReq    |             |
+//     |                 |------------->|             |
+//     |                 |   SubDelResp |             |
+//     |                 |<-------------|             |
+//     |                 | SubDelReq    |             |
+//     |                 |------------->|             |
+//     |                 |   SubDelResp |             |
+//     |                 |<-------------|             |
+//     |                 |              |             |
+//
+//-----------------------------------------------------------------------------
+
+func TestRESTSubReqRetransmissionV5(t *testing.T) {
+       CaseBegin("TestRESTSubReqRetransmissionV5")
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 3},
+               Counter{cRestSubRespToXapp, 3},
+               Counter{cSubReqToE2, 2},
+               Counter{cSubRespFromE2, 2},
+               Counter{cRestSubNotifToXapp, 4},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cSubDelReqToE2, 2},
+               Counter{cSubDelRespFromE2, 2},
+               Counter{cRestSubDelRespToXapp, 1},
+       })
+
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
+
+       <-time.After(100 * time.Millisecond)
+
+       // Send modified  requst, this time with e2 subscriptions.
+       params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
+       params2.SetSubscriptionID(&restSubId)
+
+       xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
+       xappConn1.ExpectAnyNotification(t)
+       // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
+       restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
+
+       e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
+       assert.Equal(t, e2SubsId, e2SubsId1)
+       // The first E2 subscription returns immediately, manually decrement expected request count for the remaining request handling
+       xappConn1.DecrementRequestCount()
+
+       crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
+
+       xappConn1.ExpectRESTNotification(t, restSubId_resend)
+       e2termConn1.SendSubsResp(t, crereq2, cremsg2)
+       e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
+       assert.NotEqual(t, e2SubsId2, 0)
+
+       <-time.After(100 * time.Millisecond)
+
+       xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
+       params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
+       xappConn1.ExpectAnyNotification(t)
+       // Resend the original request again with only one e2 subscription (detail), WITHOUT restsubsid
+       // md5sum shall find the original request
+       restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
+       assert.Equal(t, restSubId_resend, restSubId_resend2)
+
+       e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
+       assert.Equal(t, e2SubsId, e2SubsId1)
+
+       // Delete both e2 subscriptions
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+       e2SubsIds := []uint32{e2SubsId, e2SubsId2}
+       sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
+
+       waitSubsCleanup(t, e2SubsId, 10)
+
+       //Wait that subs is cleaned
+       mainCtrl.VerifyCounterValues(t)
+}
+
+//-----------------------------------------------------------------------------
+//   stub                             stub          stub
+// +-------+        +---------+    +---------+   +---------+
+// | xapp  |        | submgr  |    | e2term  |   |  rtmgr  |
+// +-------+        +---------+    +---------+   +---------+
+//     |                 |              |             |
+//     | RESTSubReq      |              |             |
+//     |---------------->|              |             |
+//     |     RESTSubResp |              |             |
+//     |<----------------|              |             |
+//     |                 | RouteCreate  |             |
+//     |                 |--------------------------->|
+//     |                 | RouteResponse|             |
+//     |                 |<---------------------------|
+//     |                 | SubReq       |             |
+//     |                 |------------->|             |
+//     |                 |      SubResp |             |
+//     |                 |<-------------|             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubReq      |              |             |
+//     | [with RestSUbsId + one additional e2 subDetail]
+//     |---------------->|              |             |
+//     |      RESTNotif1 |              |             |
+//     | [for initial e2 subDetail]     |             |
+//     |<----------------|              |             |
+//     |                 | RouteCreate  |             |
+//     |                 |--------------------------->|
+//     |                 | RouteResponse|             |
+//     |                 |<---------------------------|
+//     |                 | SubReq       |             |
+//     |                 |------------->|             |
+//     |                 |      SubResp |             |
+//     |                 |<-------------|             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubDelReq   |              |             |
+//     |---------------->|              |             |
+//     |   RESTSubDelResp|              |             |
+//     |<----------------|              |             |
+//     |                 | SubDelReq    |             |
+//     |                 |------------->|             |
+//     |                 |   SubDelResp |             |
+//     |                 |<-------------|             |
+//     |                 | SubDelReq    |             |
+//     |                 |------------->|             |
+//     |                 |   SubDelResp |             |
+//     |                 |<-------------|             |
+//     | RESTSubReq      |              |             |
+//     | [with RESTsubsId initial request]            |
+//     |---------------->|              |             |
+//     |     RESTSubResp |              |             |
+//     |<----------------|              |             |
+//     |                 | RouteCreate  |             |
+//     |                 |--------------------------->|
+//     |                 | RouteResponse|             |
+//     |                 |<---------------------------|
+//     |                 | SubReq       |             |
+//     |                 |------------->|             |
+//     |                 |      SubResp |             |
+//     |                 |<-------------|             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     |                 |              |             |
+//
+//-----------------------------------------------------------------------------
+func TestRESTSubReqRetransmissionV6(t *testing.T) {
+       CaseBegin("TestRESTSubReqRetransmissionV6")
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 3},
+               Counter{cRestSubRespToXapp, 3},
+               Counter{cSubReqToE2, 3},
+               Counter{cSubRespFromE2, 3},
+               Counter{cRestSubNotifToXapp, 4},
+               Counter{cRestSubDelReqFromXapp, 2},
+               Counter{cSubDelReqToE2, 3},
+               Counter{cSubDelRespFromE2, 3},
+               Counter{cRestSubDelRespToXapp, 2},
+       })
+
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
+
+       <-time.After(100 * time.Millisecond)
+
+       // Send modified  requst, this time with e2 subscriptions.
+       params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
+       params2.SetSubscriptionID(&restSubId)
+
+       xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
+       xappConn1.ExpectAnyNotification(t)
+       // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
+       restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
+
+       e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
+       assert.Equal(t, e2SubsId, e2SubsId1)
 
-       // 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)
+       crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
 
-       waiter.WaitResult(t)
+       xappConn1.ExpectRESTNotification(t, restSubId_resend)
+       e2termConn1.SendSubsResp(t, crereq2, cremsg2)
+       e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
+       assert.NotEqual(t, e2SubsId2, 0)
 
-       xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
+       <-time.After(100 * time.Millisecond)
 
-       // 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)
+       // Delete both e2 subscriptions
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+       e2SubsIds := []uint32{e2SubsId, e2SubsId2}
+       sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
 
-       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)
+       waitSubsCleanup(t, e2SubsId, 10)
 
-       // Del1
-       xappConn1.SendRESTSubsDelReq(t, &restSubId1)
-       delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
-       e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
+       // Resend the original request, we shall find it's previous md5sum/restsubs
+       // but the restsubscription has been already removed. This shall trigger a
+       // fresh create.
+       restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
 
-       // Del2
-       xappConn2.SendRESTSubsDelReq(t, &restSubId2)
-       delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
-       e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
+       <-time.After(100 * time.Millisecond)
 
-       mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
+       deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
 
-       waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
+       waitSubsCleanup(t, e2SubsId, 10)
 
+       //Wait that subs is cleaned
        mainCtrl.VerifyCounterValues(t)
 }
 
@@ -2653,14 +3198,15 @@ func TestRESTSubDelReqRetransmission(t *testing.T) {
        CaseBegin("TestRESTSubDelReqRetransmission")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        var params *teststube2ap.RESTSubsReqParams = nil
@@ -2718,14 +3264,15 @@ func TestRESTSubReqDelReq(t *testing.T) {
        CaseBegin("TestRESTSubReqDelReq")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        const subReqCount int = 1
@@ -2763,14 +3310,15 @@ func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
        CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        //Req1
@@ -2816,14 +3364,15 @@ func TestRESTSameSubsDiffRan(t *testing.T) {
        CaseBegin("TestRESTSameSubsDiffRan")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
@@ -2853,15 +3402,16 @@ func TestRESTSubReqRetryInSubmgr(t *testing.T) {
 
        // Init counter check
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubReReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
@@ -2929,12 +3479,14 @@ func TestRESTSubReqRetryInSubmgr(t *testing.T) {
 //     |                 |              |
 //
 //-----------------------------------------------------------------------------
+
 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
        CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
 
        // Init counter check
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubReReqToE2, 1},
                Counter{cSubReqTimerExpiry, 2},
@@ -2953,9 +3505,8 @@ func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
        xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
 
        delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
-       xappConn1.ExpectRESTNotification(t, restSubId)
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
        e2termConn1.SendSubsDelResp(t, delreq, delmsg)
-       // e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)     - TODO:  Should we delete this?
        xappConn1.WaitRESTNotification(t, restSubId)
 
        // Wait that subs is cleaned
@@ -2969,7 +3520,8 @@ func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
 
        // Init counter check
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubReReqToE2, 1},
                Counter{cSubReqTimerExpiry, 2},
@@ -2990,7 +3542,7 @@ func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
        e2termConn1.RecvSubsDelReq(t)
        xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
 
-       xappConn1.ExpectRESTNotification(t, restSubId)
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
        e2termConn1.RecvSubsDelReq(t)
        xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
 
@@ -3045,7 +3597,8 @@ func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
 
        // Init counter check
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubReReqToE2, 1},
                Counter{cSubReqTimerExpiry, 2},
@@ -3067,7 +3620,7 @@ func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
        e2termConn1.RecvSubsDelReq(t)
        xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
 
-       xappConn1.ExpectRESTNotification(t, restSubId)
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
        e2termConn1.RecvSubsDelReq(t)
        xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
 
@@ -3115,11 +3668,12 @@ func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
        CaseBegin("TestRESTSubReqSubFailRespInSubmgr")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubFailFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubFailNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
        })
 
        const subReqCount int = 1
@@ -3133,7 +3687,7 @@ func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
        e2termConn1.SendSubsFail(t, fparams1, cremsg1)
 
        delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
-       xappConn1.ExpectRESTNotification(t, restSubId)
+       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)
@@ -3179,15 +3733,16 @@ func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
        CaseBegin("TestRESTSubDelReqRetryInSubmgr")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelReReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
        // Req
        var params *teststube2ap.RESTSubsReqParams = nil
@@ -3238,15 +3793,16 @@ func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
        CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelReReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        // Req
@@ -3297,14 +3853,15 @@ func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
        CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelFailFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        // Req
@@ -3378,16 +3935,17 @@ func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
        CaseBegin("TestRESTSubReqAndSubDelOkSameAction")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
                Counter{cMergedSubscriptions, 1},
                Counter{cUnmergedSubscriptions, 1},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        // Req1
@@ -3402,12 +3960,12 @@ func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
        params.SetMeid("RAN_NAME_1")
 
        xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
-       xappConn2.WaitRESTNotificationForAnySubscriptionId(t)
+       xappConn2.ExpectAnyNotification(t)
        waiter := rtmgrHttp.AllocNextSleep(10, true)
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
        waiter.WaitResult(t)
        xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
-       e2SubsId2 := <-xappConn2.RESTNotification
+       e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
        xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
 
        queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
@@ -3475,14 +4033,15 @@ func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
        CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
@@ -3572,13 +4131,14 @@ func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
        CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 1},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubFailNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        const subReqCount int = 1
@@ -3675,14 +4235,15 @@ func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
        CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 1},
                Counter{cSubFailFromE2, 1},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubFailNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        const subReqCount int = 1
@@ -3732,14 +4293,15 @@ func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
 
        // Init counter check
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        const subReqCount int = 1
@@ -3816,14 +4378,15 @@ func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
        CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        const subReqCount int = 1
@@ -3833,10 +4396,10 @@ func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
        restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
 
        // Policy change
-       instanceId := int64(e2SubsId)
        // GetRESTSubsReqPolicyParams sets some coutners on tc side.
+
        params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
-       params.SubsReqParams.SubscriptionDetails[0].InstanceID = &instanceId
+       params.SetSubscriptionID(&restSubId)
        params.SetTimeToWait("w200ms")
        restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
 
@@ -3851,6 +4414,90 @@ func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
        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
 //
@@ -3897,14 +4544,15 @@ func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
 
        // Init counter check
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        const subReqCount int = 1
@@ -4022,14 +4670,15 @@ func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
        CaseBegin("TestRESTInsertSubReqAndSubDelOk")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        const subReqCount int = 1
@@ -4083,7 +4732,8 @@ func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
        CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
@@ -4159,17 +4809,19 @@ func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
 //     |<----------------|              |
 //
 //-----------------------------------------------------------------------------
+
 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
        CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        // Remove possible existing subscription
@@ -4257,20 +4909,22 @@ func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
 //     |             |                 |              |
 //
 //-----------------------------------------------------------------------------
+
 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
        CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
                Counter{cMergedSubscriptions, 1},
                Counter{cUnmergedSubscriptions, 1},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        // Remove possible existing subscription
@@ -4286,10 +4940,10 @@ func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
        params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
        params.SetMeid("RAN_NAME_1")
        xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
-       xappConn2.WaitRESTNotificationForAnySubscriptionId(t)
+       xappConn2.ExpectAnyNotification(t)
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
        xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
-       e2SubsId2 := <-xappConn2.RESTNotification
+       e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
        xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
 
        queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
@@ -4367,6 +5021,7 @@ func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
 //     |<----------------|              |
 //
 //-----------------------------------------------------------------------------
+
 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
        CaseBegin("TestRESTReportSubReqAndSubDelOk")
        subReqCount := 1
@@ -4469,14 +5124,15 @@ func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
        subReqCount := 2
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        // Req
@@ -4501,14 +5157,15 @@ func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
        subReqCount := 19
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 19},
                Counter{cSubRespFromE2, 19},
-               Counter{cSubRespToXapp, 19},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 19},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 19},
                Counter{cSubDelRespFromE2, 19},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        // Req
@@ -4532,14 +5189,15 @@ func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
        subReqCount := 2
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, uint64(subReqCount)},
                Counter{cSubRespFromE2, uint64(subReqCount)},
-               Counter{cSubRespToXapp, uint64(subReqCount)},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, uint64(subReqCount)},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, uint64(subReqCount)},
                Counter{cSubDelRespFromE2, uint64(subReqCount)},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        // Req
@@ -4565,14 +5223,15 @@ func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
        subReqCount := 2
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, uint64(subReqCount)},
                Counter{cSubRespFromE2, uint64(subReqCount)},
-               Counter{cSubRespToXapp, uint64(subReqCount)},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, uint64(subReqCount)},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, uint64(subReqCount)},
                Counter{cSubDelRespFromE2, uint64(subReqCount)},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        // Req
@@ -4598,14 +5257,15 @@ func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
        subReqCount := 19
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, uint64(subReqCount)},
                Counter{cSubRespFromE2, uint64(subReqCount)},
-               Counter{cSubRespToXapp, uint64(subReqCount)},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, uint64(subReqCount)},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, uint64(subReqCount)},
                Counter{cSubDelRespFromE2, uint64(subReqCount)},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        // Req
@@ -4630,14 +5290,15 @@ func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
        CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        // Req1
@@ -4652,7 +5313,7 @@ func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
        // Req2
        params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
        params.SetMeid("RAN_NAME_1")
-       eventTriggerDefinition := "1234"
+       eventTriggerDefinition := []int64{1234, 1}
        params.SetSubEventTriggerDefinition(eventTriggerDefinition)
 
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
@@ -4676,14 +5337,15 @@ func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
        CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        // Req1
@@ -4701,7 +5363,7 @@ func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
 
        actionId := int64(1)
        actionType := "report"
-       actionDefinition := "56781"
+       actionDefinition := []int64{5678, 1}
        subsequestActionType := "continue"
        timeToWait := "w10ms"
        params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
@@ -4727,14 +5389,15 @@ func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
        CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        // Req1
@@ -4772,14 +5435,15 @@ func TestRESTSubReqDiffActionType(t *testing.T) {
        CaseBegin("TestRESTSubReqDiffActionType")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        // Req1
@@ -4816,14 +5480,15 @@ func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
        CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        // Req1
@@ -4860,14 +5525,15 @@ func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
        CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        // Req1
@@ -4882,7 +5548,7 @@ func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
        // Req2
        params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
        params.SetMeid("RAN_NAME_1")
-       actionDefinition := "5678"
+       actionDefinition := []int64{5678, 1}
        params.SetSubActionDefinition(actionDefinition)
 
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
@@ -4906,14 +5572,15 @@ func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
        CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        // Req1
@@ -4928,7 +5595,7 @@ func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
        // Req2
        params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
        params.SetMeid("RAN_NAME_1")
-       actionDefinition := "56782"
+       actionDefinition := []int64{56782}
        params.SetSubActionDefinition(actionDefinition)
 
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
@@ -4952,14 +5619,15 @@ func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
        CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        // Req1
@@ -5026,6 +5694,7 @@ func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
 //     |                 |<-------------|
 //
 //-----------------------------------------------------------------------------
+
 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
        xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
        subReqCount := 1
@@ -5040,7 +5709,7 @@ func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
 
        _, cremsg = e2termConn1.RecvSubsReq(t)
 
-       xappConn1.ExpectRESTNotification(t, restSubId)
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
 
        // Subscription already created in E2 Node.
        fparams := &teststube2ap.E2StubSubsFailParams{}
@@ -5096,6 +5765,7 @@ func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
 //     |                 |<-------------|
 //
 //-----------------------------------------------------------------------------
+
 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
        xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
        subReqCount := 1
@@ -5113,7 +5783,7 @@ func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
 
        _, cremsg = e2termConn1.RecvSubsReq(t)
 
-       xappConn1.ExpectRESTNotification(t, restSubId)
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
 
        // Subscription already created in E2 Node.
        fparams := &teststube2ap.E2StubSubsFailParams{}
@@ -5191,7 +5861,7 @@ func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
 
        _, cremsg = e2termConn1.RecvSubsReq(t)
 
-       xappConn1.ExpectRESTNotification(t, restSubId)
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
 
        // Subscription already created in E2 Node.
        fparams := &teststube2ap.E2StubSubsFailParams{}
@@ -5267,7 +5937,7 @@ func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
 
        _, cremsg = e2termConn1.RecvSubsReq(t)
 
-       xappConn1.ExpectRESTNotification(t, restSubId)
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
 
        // Subscription already created in E2 Node.
        fparams := &teststube2ap.E2StubSubsFailParams{}
@@ -5341,7 +6011,7 @@ func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
 
        _, cremsg = e2termConn1.RecvSubsReq(t)
 
-       xappConn1.ExpectRESTNotification(t, restSubId)
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
 
        // Subscription already created in E2 Node.
        fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
@@ -5414,7 +6084,7 @@ func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
 
        _, cremsg = e2termConn1.RecvSubsReq(t)
 
-       xappConn1.ExpectRESTNotification(t, restSubId)
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
 
        // Subscription already created in E2 Node.
        fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
@@ -5838,10 +6508,11 @@ func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelFailFromE2, 1},
-               Counter{cSubRespToXapp, 1},
+               Counter{cRestSubFailNotifToXapp, 1},
        })
 
        subReqCount := 1
@@ -5856,7 +6527,7 @@ func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
 
        // E2t: Receive SubsDelReq
        delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
-       xappConn1.ExpectRESTNotification(t, restSubId)
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
 
        // Subscription does not exist in in E2 Node.
        e2termConn1.SendSubsDelFail(t, delreq, delmsg)
(near-realtime) RIC Platform Subscription Manager