pkg/control/ut_messaging_test.go

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2019 AT&T Intellectual Property.
   4   Copyright (c) 2019 Nokia
   5
   6    Licensed under the Apache License, Version 2.0 (the "License");
   7    you may not use this file except in compliance with the License.
   8    You may obtain a copy of the License at
   9
  10        http://www.apache.org/licenses/LICENSE-2.0
  11
  12    Unless required by applicable law or agreed to in writing, software
  13    distributed under the License is distributed on an "AS IS" BASIS,
  14    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15    See the License for the specific language governing permissions and
  16    limitations under the License.
  17 ==================================================================================
  18 */
  19
  20 package control
  21
  22 import (
  23         "testing"
  24         "time"
  25
  26         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
  27         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper"
  28         "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststube2ap"
  29         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
  30         "github.com/stretchr/testify/assert"
  31 )
  32
  33 func TestSuiteSetup(t *testing.T) {
  34         // The effect of this call shall endure thgough the UT suite!
  35         // If this causes any issues, the previout interface can be restored
  36         // like this:git log
  37         // SetPackerIf(e2ap_wrapper.NewAsn1E2APPacker())
  38
  39         SetPackerIf(e2ap_wrapper.NewUtAsn1E2APPacker())
  40 }
  41
  42 //-----------------------------------------------------------------------------
  43 // TestRESTSubReqAndDeleteOkWithE2apUtWrapper
  44 //
  45 //   stub                             stub          stub
  46 // +-------+        +---------+    +---------+   +---------+
  47 // | xapp  |        | submgr  |    | e2term  |   |  rtmgr  |
  48 // +-------+        +---------+    +---------+   +---------+
  49 //     |                 |              |             |
  50 //     | RESTSubReq      |              |             |
  51 //     |---------------->|              |             |
  52 //     |                 | RouteCreate  |             |
  53 //     |                 |--------------------------->|  // The order of these events may vary
  54 //     |                 |              |             |
  55 //     |     RESTSubResp |              |             |  // The order of these events may vary
  56 //     |<----------------|              |             |
  57 //     |                 | RouteResponse|             |
  58 //     |                 |<---------------------------|  // The order of these events may vary
  59 //     |                 |              |             |
  60 //     |                 | SubReq       |             |
  61 //     |                 |------------->|             |  // The order of these events may vary
  62 //     |                 |              |             |
  63 //     |                 |      SubResp |             |
  64 //     |                 |<-------------|             |
  65 //     |      RESTNotif1 |              |             |
  66 //     |<----------------|              |             |
  67 //     |                 |              |             |
  68 //     | RESTSubDelReq   |              |             |
  69 //     |---------------->|              |             |
  70 //     |                 | SubDelReq    |             |
  71 //     |                 |------------->|             |
  72 //     |                 |              |             |
  73 //     |   RESTSubDelResp|              |             |
  74 //     |<----------------|              |             |
  75 //     |                 |              |             |
  76 //     |                 |   SubDelResp |             |
  77 //     |                 |<-------------|             |
  78 //     |                 |              |             |
  79 //     |                 |              |             |
  80 //
  81 //-----------------------------------------------------------------------------
  82 func TestRESTSubReqAndDeleteOkWithE2apUtWrapper(t *testing.T) {
  83
  84         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
  85
  86         deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
  87
  88         waitSubsCleanup(t, e2SubsId, 10)
  89 }
  90
  91 //-----------------------------------------------------------------------------
  92 // TestRESTSubReqAndE1apDeleteReqPackingError
  93 //
  94 //   stub                             stub          stub
  95 // +-------+        +---------+    +---------+   +---------+
  96 // | xapp  |        | submgr  |    | e2term  |   |  rtmgr  |
  97 // +-------+        +---------+    +---------+   +---------+
  98 //     |                 |              |             |
  99 //     | RESTSubReq      |              |             |
 100 //     |---------------->|              |             |
 101 //     |                 | RouteCreate  |             |
 102 //     |                 |--------------------------->|  // The order of these events may vary
 103 //     |                 |              |             |
 104 //     |     RESTSubResp |              |             |  // The order of these events may vary
 105 //     |<----------------|              |             |
 106 //     |                 | RouteResponse|             |
 107 //     |                 |<---------------------------|  // The order of these events may vary
 108 //     |                 |              |             |
 109 //     |                 | SubReq       |             |
 110 //     |                 |------------->|             |  // The order of these events may vary
 111 //     |                 |              |             |
 112 //     |                 |      SubResp |             |
 113 //     |                 |<-------------|             |
 114 //     |      RESTNotif1 |              |             |
 115 //     |<----------------|              |             |
 116 //     |                 |              |             |
 117 //     | RESTSubDelReq   |              |             |
 118 //     |---------------->|              |             |
 119 //     |                 |              |             |
 120 //     |   RESTSubDelResp|              |             |
 121 //     |<----------------|              |             |
 122 //     |                 |              |             |
 123 //     |                 |              |             |
 124 //
 125 //-----------------------------------------------------------------------------
 126 func TestRESTSubReqAndE1apDeleteReqPackingError(t *testing.T) {
 127
 128         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
 129
 130         e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, false)
 131         xappConn1.SendRESTSubsDelReq(t, &restSubId)
 132         defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, true)
 133
 134         waitSubsCleanup(t, e2SubsId, 10)
 135 }
 136
 137 //-----------------------------------------------------------------------------
 138 // TestRESTSubReqAndE1apDeleteRespUnpackingError
 139 //
 140 //   stub                             stub          stub
 141 // +-------+        +---------+    +---------+   +---------+
 142 // | xapp  |        | submgr  |    | e2term  |   |  rtmgr  |
 143 // +-------+        +---------+    +---------+   +---------+
 144 //     |                 |              |             |
 145 //     | RESTSubReq      |              |             |
 146 //     |---------------->|              |             |
 147 //     |                 | RouteCreate  |             |
 148 //     |                 |--------------------------->|  // The order of these events may vary
 149 //     |                 |              |             |
 150 //     |     RESTSubResp |              |             |  // The order of these events may vary
 151 //     |<----------------|              |             |
 152 //     |                 | RouteResponse|             |
 153 //     |                 |<---------------------------|  // The order of these events may vary
 154 //     |                 |              |             |
 155 //     |                 | SubReq       |             |
 156 //     |                 |------------->|             |  // The order of these events may vary
 157 //     |                 |              |             |
 158 //     |                 |      SubResp |             |
 159 //     |                 |<-------------|             |
 160 //     |      RESTNotif1 |              |             |
 161 //     |<----------------|              |             |
 162 //     |                 |              |             |
 163 //     | RESTSubDelReq   |              |             |
 164 //     |---------------->|              |             |
 165 //     |                 | SubDelReq    |             |
 166 //     |                 |------------->|             |
 167 //     |                 |              |             |
 168 //     |   RESTSubDelResp|              |             |
 169 //     |<----------------|              |             | // The order of these events may vary
 170 //     |                 |              |             |
 171 //     |                 |   SubDelResp |             |
 172 //     |                 |<-------------|             | // 1.st NOK
 173 //     |                 |              |             |
 174 //     |                 | SubDelReq    |             |
 175 //     |                 |------------->|             |
 176 //     |                 |              |             |
 177 //     |                 |   SubDelResp |             |
 178 //     |                 |<-------------|             | // 2.nd NOK
 179 //
 180 //-----------------------------------------------------------------------------
 181
 182 func TestRESTSubReqAndE1apDeleteRespUnpackingError(t *testing.T) {
 183
 184         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
 185
 186         xappConn1.SendRESTSubsDelReq(t, &restSubId)
 187         e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, false)
 188         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
 189         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
 190
 191         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
 192         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
 193
 194         defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, true)
 195
 196         waitSubsCleanup(t, e2SubsId, 10)
 197 }
 198
 199 //-----------------------------------------------------------------------------
 200 // TestSubReqAndRouteNok
 201 //
 202 //   stub                          stub
 203 // +-------+     +---------+    +---------+
 204 // | xapp  |     | submgr  |    |  rtmgr  |
 205 // +-------+     +---------+    +---------+
 206 //     |              |              |
 207 //     | SubReq       |              |
 208 //     |------------->|              |
 209 //     |              |              |
 210 //     |              | RouteCreate  |
 211 //     |              |------------->|
 212 //     |              |              |
 213 //     |              | RouteCreate  |
 214 //     |              |  status:400  |
 215 //     |              |<-------------|
 216 //     |              |              |
 217 //     |       [SUBS INT DELETE]     |
 218 //     |              |              |
 219 //
 220 //-----------------------------------------------------------------------------
 221
 222 func TestSubReqAndRouteNok(t *testing.T) {
 223         CaseBegin("TestSubReqAndRouteNok")
 224
 225         // Init counter check
 226         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
 227                 Counter{cSubReqFromXapp, 1},
 228                 Counter{cRouteCreateFail, 1},
 229         })
 230
 231         waiter := rtmgrHttp.AllocNextEvent(false)
 232         newSubsId := mainCtrl.get_registry_next_subid(t)
 233         xappConn1.SendSubsReq(t, nil, nil)
 234         waiter.WaitResult(t)
 235
 236         //Wait that subs is cleaned
 237         mainCtrl.wait_subs_clean(t, newSubsId, 10)
 238
 239         xappConn1.TestMsgChanEmpty(t)
 240         xappConn2.TestMsgChanEmpty(t)
 241         e2termConn1.TestMsgChanEmpty(t)
 242         mainCtrl.wait_registry_empty(t, 10)
 243
 244         <-time.After(1 * time.Second)
 245         mainCtrl.VerifyCounterValues(t)
 246 }
 247
 248 //-----------------------------------------------------------------------------
 249 // TestSubReqAndRouteUpdateNok
 250
 251 //   stub                          stub
 252 // +-------+     +-------+     +---------+    +---------+
 253 // | xapp2 |     | xapp1 |     | submgr  |    |  rtmgr  |
 254 // +-------+     +-------+     +---------+    +---------+
 255 //     |             |              |              |
 256 //     |        [SUBS CREATE]       |              |
 257 //     |             |              |              |
 258 //     |             |              |              |
 259 //     |             |              |              |
 260 //     | SubReq (mergeable)         |              |
 261 //     |--------------------------->|              |              |
 262 //     |             |              |              |
 263 //     |             |              | RouteUpdate  |
 264 //     |             |              |------------->|
 265 //     |             |              |              |
 266 //     |             |              | RouteUpdate  |
 267 //     |             |              |  status:400  |
 268 //     |             |              |<-------------|
 269 //     |             |              |              |
 270 //     |       [SUBS INT DELETE]    |              |
 271 //     |             |              |              |
 272 //     |             |              |              |
 273 //     |        [SUBS DELETE]       |              |
 274 //     |             |              |              |
 275
 276 func TestSubReqAndRouteUpdateNok(t *testing.T) {
 277         CaseBegin("TestSubReqAndRouteUpdateNok")
 278
 279         // Init counter check
 280         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
 281                 Counter{cSubReqFromXapp, 2},
 282                 Counter{cSubReqToE2, 1},
 283                 Counter{cSubRespFromE2, 1},
 284                 Counter{cSubRespToXapp, 1},
 285                 Counter{cRouteCreateUpdateFail, 1},
 286                 Counter{cSubDelReqFromXapp, 1},
 287                 Counter{cSubDelReqToE2, 1},
 288                 Counter{cSubDelRespFromE2, 1},
 289                 Counter{cSubDelRespToXapp, 1},
 290         })
 291
 292         cretrans := xappConn1.SendSubsReq(t, nil, nil)
 293         crereq, cremsg := e2termConn1.RecvSubsReq(t)
 294         e2termConn1.SendSubsResp(t, crereq, cremsg)
 295         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
 296
 297         resp, _ := xapp.Subscription.QuerySubscriptions()
 298         assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
 299         assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
 300         assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
 301
 302         waiter := rtmgrHttp.AllocNextEvent(false)
 303         newSubsId := mainCtrl.get_registry_next_subid(t)
 304         xappConn2.SendSubsReq(t, nil, nil)
 305         waiter.WaitResult(t)
 306
 307         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
 308         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
 309
 310         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
 311         xappConn1.RecvSubsDelResp(t, deltrans)
 312
 313         //Wait that subs is cleaned
 314         mainCtrl.wait_subs_clean(t, newSubsId, 10)
 315         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 316
 317         xappConn1.TestMsgChanEmpty(t)
 318         xappConn2.TestMsgChanEmpty(t)
 319         e2termConn1.TestMsgChanEmpty(t)
 320         mainCtrl.wait_registry_empty(t, 10)
 321
 322         mainCtrl.VerifyCounterValues(t)
 323 }
 324
 325 //-----------------------------------------------------------------------------
 326 // TestSubDelReqAndRouteDeleteNok
 327 //
 328 //   stub                          stub
 329 // +-------+     +---------+    +---------+    +---------+
 330 // | xapp  |     | submgr  |    | e2term  |    |  rtmgr  |
 331 // +-------+     +---------+    +---------+    +---------+
 332 //     |              |              |              |
 333 //     |         [SUBS CREATE]       |              |
 334 //     |              |              |              |
 335 //     |              |              |              |
 336 //     |              |              |              |
 337 //     | SubDelReq    |              |              |
 338 //     |------------->|              |              |
 339 //     |              |  SubDelReq   |              |
 340 //     |              |------------->|              |
 341 //     |              |  SubDelRsp   |              |
 342 //     |              |<-------------|              |
 343 //     |  SubDelRsp   |              |              |
 344 //     |<-------------|              |              |
 345 //     |              | RouteDelete  |              |
 346 //     |              |---------------------------->|
 347 //     |              |              |              |
 348 //     |              | RouteDelete  |              |
 349 //     |              |  status:400  |              |
 350 //     |              |<----------------------------|
 351 //     |              |              |              |
 352 func TestSubDelReqAndRouteDeleteNok(t *testing.T) {
 353         CaseBegin("TestSubDelReqAndRouteDeleteNok")
 354
 355         // Init counter check
 356         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
 357                 Counter{cSubReqFromXapp, 1},
 358                 Counter{cSubReqToE2, 1},
 359                 Counter{cSubRespFromE2, 1},
 360                 Counter{cSubRespToXapp, 1},
 361                 Counter{cSubDelReqFromXapp, 1},
 362                 Counter{cRouteDeleteFail, 1},
 363                 Counter{cSubDelReqToE2, 1},
 364                 Counter{cSubDelRespFromE2, 1},
 365                 Counter{cSubDelRespToXapp, 1},
 366         })
 367
 368         cretrans := xappConn1.SendSubsReq(t, nil, nil)
 369         crereq, cremsg := e2termConn1.RecvSubsReq(t)
 370         e2termConn1.SendSubsResp(t, crereq, cremsg)
 371         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
 372
 373         resp, _ := xapp.Subscription.QuerySubscriptions()
 374         assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
 375         assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
 376         assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
 377
 378         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
 379         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
 380
 381         waiter := rtmgrHttp.AllocNextEvent(false)
 382         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
 383         waiter.WaitResult(t)
 384
 385         xappConn1.RecvSubsDelResp(t, deltrans)
 386
 387         //Wait that subs is cleaned
 388         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 389
 390         xappConn1.TestMsgChanEmpty(t)
 391         xappConn2.TestMsgChanEmpty(t)
 392         e2termConn1.TestMsgChanEmpty(t)
 393         mainCtrl.wait_registry_empty(t, 10)
 394
 395         mainCtrl.VerifyCounterValues(t)
 396 }
 397
 398 //-----------------------------------------------------------------------------
 399 // TestSubMergeDelAndRouteUpdateNok
 400 //   stub                          stub
 401 // +-------+     +-------+     +---------+    +---------+
 402 // | xapp2 |     | xapp1 |     | submgr  |    | e2term  |
 403 // +-------+     +-------+     +---------+    +---------+
 404 //     |             |              |              |
 405 //     |             |              |              |
 406 //     |             |              |              |
 407 //     |             | SubReq1      |              |
 408 //     |             |------------->|              |
 409 //     |             |              |              |
 410 //     |             |              | SubReq1      |
 411 //     |             |              |------------->|
 412 //     |             |              |    SubResp1  |
 413 //     |             |              |<-------------|
 414 //     |             |    SubResp1  |              |
 415 //     |             |<-------------|              |
 416 //     |             |              |              |
 417 //     |          SubReq2           |              |
 418 //     |--------------------------->|              |
 419 //     |             |              |              |
 420 //     |          SubResp2          |              |
 421 //     |<---------------------------|              |
 422 //     |             |              |              |
 423 //     |             | SubDelReq 1  |              |
 424 //     |             |------------->|              |
 425 //     |             |              | RouteUpdate  |
 426 //     |             |              |-----> rtmgr  |
 427 //     |             |              |              |
 428 //     |             |              | RouteUpdate  |
 429 //     |             |              |  status:400  |
 430 //     |             |              |<----- rtmgr  |
 431 //     |             |              |              |
 432 //     |             | SubDelResp 1 |              |
 433 //     |             |<-------------|              |
 434 //     |             |              |              |
 435 //     |         SubDelReq 2        |              |
 436 //     |--------------------------->|              |
 437 //     |             |              |              |
 438 //     |             |              | SubDelReq 2  |
 439 //     |             |              |------------->|
 440 //     |             |              |              |
 441 //     |             |              | SubDelReq 2  |
 442 //     |             |              |------------->|
 443 //     |             |              |              |
 444 //     |         SubDelResp 2       |              |
 445 //     |<---------------------------|              |
 446 //
 447 //-----------------------------------------------------------------------------
 448 func TestSubMergeDelAndRouteUpdateNok(t *testing.T) {
 449         CaseBegin("TestSubMergeDelAndRouteUpdateNok")
 450
 451         // Init counter check
 452         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
 453                 Counter{cSubReqFromXapp, 2},
 454                 Counter{cSubReqToE2, 1},
 455                 Counter{cSubRespFromE2, 1},
 456                 Counter{cSubRespToXapp, 2},
 457                 Counter{cSubDelReqFromXapp, 2},
 458                 Counter{cRouteDeleteUpdateFail, 1},
 459                 Counter{cSubDelReqToE2, 1},
 460                 Counter{cSubDelRespFromE2, 1},
 461                 Counter{cSubDelRespToXapp, 2},
 462         })
 463
 464         //Req1
 465         rparams1 := &teststube2ap.E2StubSubsReqParams{}
 466         rparams1.Init()
 467         cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
 468         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
 469         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
 470         e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
 471
 472         //Req2
 473         rparams2 := &teststube2ap.E2StubSubsReqParams{}
 474         rparams2.Init()
 475         cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
 476         e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
 477
 478         resp, _ := xapp.Subscription.QuerySubscriptions()
 479         assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
 480         assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
 481         assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
 482
 483         //Del1
 484         waiter := rtmgrHttp.AllocNextEvent(false)
 485         deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
 486         waiter.WaitResult(t)
 487
 488         xappConn1.RecvSubsDelResp(t, deltrans1)
 489
 490         //Del2
 491         deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
 492         delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
 493         e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
 494         xappConn2.RecvSubsDelResp(t, deltrans2)
 495         //Wait that subs is cleaned
 496         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
 497
 498         xappConn1.TestMsgChanEmpty(t)
 499         xappConn2.TestMsgChanEmpty(t)
 500         e2termConn1.TestMsgChanEmpty(t)
 501         mainCtrl.wait_registry_empty(t, 10)
 502
 503         mainCtrl.VerifyCounterValues(t)
 504 }
 505
 506 //-----------------------------------------------------------------------------
 507
 508 //-----------------------------------------------------------------------------
 509 // TestSubReqAndSubDelOk
 510 //
 511 //   stub                          stub
 512 // +-------+     +---------+    +---------+
 513 // | xapp  |     | submgr  |    | e2term  |
 514 // +-------+     +---------+    +---------+
 515 //     |              |              |
 516 //     | SubReq       |              |
 517 //     |------------->|              |
 518 //     |              |              |
 519 //     |              | SubReq       |
 520 //     |              |------------->|
 521 //     |              |              |
 522 //     |              |      SubResp |
 523 //     |              |<-------------|
 524 //     |              |              |
 525 //     |      SubResp |              |
 526 //     |<-------------|              |
 527 //     |              |              |
 528 //     |              |              |
 529 //     | SubDelReq    |              |
 530 //     |------------->|              |
 531 //     |              |              |
 532 //     |              | SubDelReq    |
 533 //     |              |------------->|
 534 //     |              |              |
 535 //     |              |   SubDelResp |
 536 //     |              |<-------------|
 537 //     |              |              |
 538 //     |   SubDelResp |              |
 539 //     |<-------------|              |
 540 //
 541 //-----------------------------------------------------------------------------
 542 func TestSubReqAndSubDelOk(t *testing.T) {
 543         CaseBegin("TestSubReqAndSubDelOk")
 544
 545         // Init counter check
 546         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
 547                 Counter{cSubReqFromXapp, 1},
 548                 Counter{cSubReqToE2, 1},
 549                 Counter{cSubRespFromE2, 1},
 550                 Counter{cSubRespToXapp, 1},
 551                 Counter{cSubDelReqFromXapp, 1},
 552                 Counter{cSubDelReqToE2, 1},
 553                 Counter{cSubDelRespFromE2, 1},
 554                 Counter{cSubDelRespToXapp, 1},
 555         })
 556
 557         cretrans := xappConn1.SendSubsReq(t, nil, nil)
 558         crereq, cremsg := e2termConn1.RecvSubsReq(t)
 559         e2termConn1.SendSubsResp(t, crereq, cremsg)
 560         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
 561
 562         resp, _ := xapp.Subscription.QuerySubscriptions()
 563         assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
 564         assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
 565         assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
 566
 567         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
 568         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
 569
 570         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
 571         xappConn1.RecvSubsDelResp(t, deltrans)
 572
 573         //Wait that subs is cleaned
 574         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 575
 576         xappConn1.TestMsgChanEmpty(t)
 577         xappConn2.TestMsgChanEmpty(t)
 578         e2termConn1.TestMsgChanEmpty(t)
 579         mainCtrl.wait_registry_empty(t, 10)
 580
 581         mainCtrl.VerifyCounterValues(t)
 582 }
 583
 584 //-----------------------------------------------------------------------------
 585 // TestSubReqRetransmission
 586 //
 587 //   stub                          stub
 588 // +-------+     +---------+    +---------+
 589 // | xapp  |     | submgr  |    | e2term  |
 590 // +-------+     +---------+    +---------+
 591 //     |              |              |
 592 //     |  SubReq      |              |
 593 //     |------------->|              |
 594 //     |              |              |
 595 //     |              | SubReq       |
 596 //     |              |------------->|
 597 //     |              |              |
 598 //     |  SubReq      |              |
 599 //     | (retrans)    |              |
 600 //     |------------->|              |
 601 //     |              |              |
 602 //     |              |      SubResp |
 603 //     |              |<-------------|
 604 //     |              |              |
 605 //     |      SubResp |              |
 606 //     |<-------------|              |
 607 //     |              |              |
 608 //     |         [SUBS DELETE]       |
 609 //     |              |              |
 610 //
 611 //-----------------------------------------------------------------------------
 612 func TestSubReqRetransmission(t *testing.T) {
 613         CaseBegin("TestSubReqRetransmission")
 614
 615         //Subs Create
 616         cretrans := xappConn1.SendSubsReq(t, nil, nil)
 617         crereq, cremsg := e2termConn1.RecvSubsReq(t)
 618
 619         seqBef := mainCtrl.get_msgcounter(t)
 620         xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq
 621         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 622
 623         // hack as there is no real way to see has message be handled.
 624         // Previuos counter check just tells that is has been received by submgr
 625         // --> artificial delay
 626         <-time.After(1 * time.Second)
 627         e2termConn1.SendSubsResp(t, crereq, cremsg)
 628         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
 629
 630         //Subs Delete
 631         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
 632         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
 633         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
 634         xappConn1.RecvSubsDelResp(t, deltrans)
 635
 636         //Wait that subs is cleaned
 637         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 638
 639         xappConn1.TestMsgChanEmpty(t)
 640         xappConn2.TestMsgChanEmpty(t)
 641         e2termConn1.TestMsgChanEmpty(t)
 642         mainCtrl.wait_registry_empty(t, 10)
 643 }
 644
 645 //-----------------------------------------------------------------------------
 646 // TestSubDelReqRetransmission
 647 //
 648 //   stub                          stub
 649 // +-------+     +---------+    +---------+
 650 // | xapp  |     | submgr  |    | e2term  |
 651 // +-------+     +---------+    +---------+
 652 //     |              |              |
 653 //     |         [SUBS CREATE]       |
 654 //     |              |              |
 655 //     |              |              |
 656 //     | SubDelReq    |              |
 657 //     |------------->|              |
 658 //     |              |              |
 659 //     |              | SubDelReq    |
 660 //     |              |------------->|
 661 //     |              |              |
 662 //     | SubDelReq    |              |
 663 //     | (same sub)   |              |
 664 //     | (same xid)   |              |
 665 //     |------------->|              |
 666 //     |              |              |
 667 //     |              |   SubDelResp |
 668 //     |              |<-------------|
 669 //     |              |              |
 670 //     |   SubDelResp |              |
 671 //     |<-------------|              |
 672 //
 673 //-----------------------------------------------------------------------------
 674 func TestSubDelReqRetransmission(t *testing.T) {
 675         CaseBegin("TestSubDelReqRetransmission")
 676
 677         //Subs Create
 678         cretrans := xappConn1.SendSubsReq(t, nil, nil)
 679         crereq, cremsg := e2termConn1.RecvSubsReq(t)
 680         e2termConn1.SendSubsResp(t, crereq, cremsg)
 681         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
 682
 683         //Subs Delete
 684         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
 685         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
 686
 687         seqBef := mainCtrl.get_msgcounter(t)
 688         xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq
 689         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 690
 691         // hack as there is no real way to see has message be handled.
 692         // Previuos counter check just tells that is has been received by submgr
 693         // --> artificial delay
 694         <-time.After(1 * time.Second)
 695
 696         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
 697         xappConn1.RecvSubsDelResp(t, deltrans)
 698
 699         //Wait that subs is cleaned
 700         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 701
 702         xappConn1.TestMsgChanEmpty(t)
 703         xappConn2.TestMsgChanEmpty(t)
 704         e2termConn1.TestMsgChanEmpty(t)
 705         mainCtrl.wait_registry_empty(t, 10)
 706 }
 707
 708 //-----------------------------------------------------------------------------
 709 // TestSubDelReqCollision
 710 //
 711 //   stub                          stub
 712 // +-------+     +---------+    +---------+
 713 // | xapp  |     | submgr  |    | e2term  |
 714 // +-------+     +---------+    +---------+
 715 //     |              |              |
 716 //     |         [SUBS CREATE]       |
 717 //     |              |              |
 718 //     |              |              |
 719 //     | SubDelReq 1  |              |
 720 //     |------------->|              |
 721 //     |              |              |
 722 //     |              | SubDelReq 1  |
 723 //     |              |------------->|
 724 //     |              |              |
 725 //     | SubDelReq 2  |              |
 726 //     | (same sub)   |              |
 727 //     | (diff xid)   |              |
 728 //     |------------->|              |
 729 //     |              |              |
 730 //     |              | SubDelResp 1 |
 731 //     |              |<-------------|
 732 //     |              |              |
 733 //     | SubDelResp 1 |              |
 734 //     |<-------------|              |
 735 //     |              |              |
 736 //     | SubDelResp 2 |              |
 737 //     |<-------------|              |
 738 //
 739 //-----------------------------------------------------------------------------
 740
 741 func TestSubDelReqCollision(t *testing.T) {
 742         CaseBegin("TestSubDelReqCollision")
 743
 744         //Subs Create
 745         cretrans := xappConn1.SendSubsReq(t, nil, nil)
 746         crereq, cremsg := e2termConn1.RecvSubsReq(t)
 747         e2termConn1.SendSubsResp(t, crereq, cremsg)
 748         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
 749
 750         //Subs Delete
 751         xappConn1.SendSubsDelReq(t, nil, e2SubsId)
 752         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
 753
 754         // Subs Delete colliding
 755         seqBef := mainCtrl.get_msgcounter(t)
 756         deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
 757         xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq
 758         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 759
 760         // hack as there is no real way to see has message be handled.
 761         // Previuos counter check just tells that is has been received by submgr
 762         // --> artificial delay
 763         <-time.After(1 * time.Second)
 764
 765         // Del resp for first and second
 766         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
 767
 768         // don't care in which order responses are received
 769         xappConn1.RecvSubsDelResp(t, nil)
 770         xappConn1.RecvSubsDelResp(t, nil)
 771
 772         //Wait that subs is cleaned
 773         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 774
 775         xappConn1.TestMsgChanEmpty(t)
 776         xappConn2.TestMsgChanEmpty(t)
 777         e2termConn1.TestMsgChanEmpty(t)
 778         mainCtrl.wait_registry_empty(t, 10)
 779 }
 780
 781 //-----------------------------------------------------------------------------
 782 // TestSubReqAndSubDelOkTwoParallel
 783 //
 784 //   stub       stub                          stub
 785 // +-------+  +-------+     +---------+    +---------+
 786 // | xapp  |  | xapp  |     | submgr  |    | e2term  |
 787 // +-------+  +-------+     +---------+    +---------+
 788 //     |          |              |              |
 789 //     |          |              |              |
 790 //     |          |              |              |
 791 //     |          | SubReq1      |              |
 792 //     |          |------------->|              |
 793 //     |          |              |              |
 794 //     |          |              | SubReq1      |
 795 //     |          |              |------------->|
 796 //     |          |              |              |
 797 //     |       SubReq2           |              |
 798 //     |------------------------>|              |
 799 //     |          |              |              |
 800 //     |          |              | SubReq2      |
 801 //     |          |              |------------->|
 802 //     |          |              |              |
 803 //     |          |              |    SubResp1  |
 804 //     |          |              |<-------------|
 805 //     |          |    SubResp1  |              |
 806 //     |          |<-------------|              |
 807 //     |          |              |              |
 808 //     |          |              |    SubResp2  |
 809 //     |          |              |<-------------|
 810 //     |       SubResp2          |              |
 811 //     |<------------------------|              |
 812 //     |          |              |              |
 813 //     |          |        [SUBS 1 DELETE]      |
 814 //     |          |              |              |
 815 //     |          |        [SUBS 2 DELETE]      |
 816 //     |          |              |              |
 817 //
 818 //-----------------------------------------------------------------------------
 819
 820 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
 821         CaseBegin("TestSubReqAndSubDelOkTwoParallel")
 822
 823         //Req1
 824         rparams1 := &teststube2ap.E2StubSubsReqParams{}
 825         rparams1.Init()
 826         cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
 827         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
 828
 829         //Req2
 830         rparams2 := &teststube2ap.E2StubSubsReqParams{}
 831         rparams2.Init()
 832
 833         rparams2.Req.EventTriggerDefinition.Data.Length = 1
 834         rparams2.Req.EventTriggerDefinition.Data.Data = make([]uint8, rparams2.Req.EventTriggerDefinition.Data.Length)
 835         rparams2.Req.EventTriggerDefinition.Data.Data[0] = 2
 836
 837         cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
 838         crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
 839
 840         //Resp1
 841         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
 842         e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
 843
 844         //Resp2
 845         e2termConn1.SendSubsResp(t, crereq2, cremsg2)
 846         e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
 847
 848         //Del1
 849         deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
 850         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
 851         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
 852         xappConn1.RecvSubsDelResp(t, deltrans1)
 853         //Wait that subs is cleaned
 854         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
 855
 856         //Del2
 857         deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
 858         delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
 859         e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
 860         xappConn2.RecvSubsDelResp(t, deltrans2)
 861         //Wait that subs is cleaned
 862         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
 863
 864         xappConn1.TestMsgChanEmpty(t)
 865         xappConn2.TestMsgChanEmpty(t)
 866         e2termConn1.TestMsgChanEmpty(t)
 867         mainCtrl.wait_registry_empty(t, 10)
 868 }
 869
 870 //-----------------------------------------------------------------------------
 871 // TestSameSubsDiffRan
 872 // Same subscription to different RANs
 873 //
 874 //   stub                          stub
 875 // +-------+     +---------+    +---------+
 876 // | xapp  |     | submgr  |    | e2term  |
 877 // +-------+     +---------+    +---------+
 878 //     |              |              |
 879 //     |              |              |
 880 //     |              |              |
 881 //     | SubReq(r1)   |              |
 882 //     |------------->|              |
 883 //     |              |              |
 884 //     |              | SubReq(r1)   |
 885 //     |              |------------->|
 886 //     |              |              |
 887 //     |              | SubResp(r1)  |
 888 //     |              |<-------------|
 889 //     |              |              |
 890 //     | SubResp(r1)  |              |
 891 //     |<-------------|              |
 892 //     |              |              |
 893 //     | SubReq(r2)   |              |
 894 //     |------------->|              |
 895 //     |              |              |
 896 //     |              | SubReq(r2)   |
 897 //     |              |------------->|
 898 //     |              |              |
 899 //     |              | SubResp(r2)  |
 900 //     |              |<-------------|
 901 //     |              |              |
 902 //     | SubResp(r2)  |              |
 903 //     |<-------------|              |
 904 //     |              |              |
 905 //     |       [SUBS r1 DELETE]      |
 906 //     |              |              |
 907 //     |       [SUBS r2 DELETE]      |
 908 //     |              |              |
 909 //
 910 //-----------------------------------------------------------------------------
 911 func TestSameSubsDiffRan(t *testing.T) {
 912         CaseBegin("TestSameSubsDiffRan")
 913
 914         //Req1
 915         cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
 916         xappConn1.SendSubsReq(t, nil, cretrans1)
 917         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
 918         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
 919         e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
 920
 921         //Req2
 922         cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
 923         xappConn1.SendSubsReq(t, nil, cretrans2)
 924         crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
 925         e2termConn1.SendSubsResp(t, crereq2, cremsg2)
 926         e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
 927
 928         //Del1
 929         deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
 930         xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
 931         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
 932         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
 933         xappConn1.RecvSubsDelResp(t, deltrans1)
 934         //Wait that subs is cleaned
 935         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
 936
 937         //Del2
 938         deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
 939         xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
 940         delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
 941         e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
 942         xappConn1.RecvSubsDelResp(t, deltrans2)
 943         //Wait that subs is cleaned
 944         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
 945
 946         xappConn1.TestMsgChanEmpty(t)
 947         xappConn2.TestMsgChanEmpty(t)
 948         e2termConn1.TestMsgChanEmpty(t)
 949         mainCtrl.wait_registry_empty(t, 10)
 950 }
 951
 952 //-----------------------------------------------------------------------------
 953 // TestSubReqRetryInSubmgr
 954 //
 955 //   stub                          stub
 956 // +-------+     +---------+    +---------+
 957 // | xapp  |     | submgr  |    | e2term  |
 958 // +-------+     +---------+    +---------+
 959 //     |              |              |
 960 //     |  SubReq      |              |
 961 //     |------------->|              |
 962 //     |              |              |
 963 //     |              | SubReq       |
 964 //     |              |------------->|
 965 //     |              |              |
 966 //     |              |              |
 967 //     |              | SubReq       |
 968 //     |              |------------->|
 969 //     |              |              |
 970 //     |              |      SubResp |
 971 //     |              |<-------------|
 972 //     |              |              |
 973 //     |      SubResp |              |
 974 //     |<-------------|              |
 975 //     |              |              |
 976 //     |         [SUBS DELETE]       |
 977 //     |              |              |
 978 //
 979 //-----------------------------------------------------------------------------
 980
 981 func TestSubReqRetryInSubmgr(t *testing.T) {
 982         CaseBegin("TestSubReqRetryInSubmgr start")
 983
 984         // Init counter check
 985         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
 986                 Counter{cSubReqFromXapp, 1},
 987                 Counter{cSubReqToE2, 1},
 988                 Counter{cSubReReqToE2, 1},
 989                 Counter{cSubRespFromE2, 1},
 990                 Counter{cSubRespToXapp, 1},
 991                 Counter{cSubDelReqFromXapp, 1},
 992                 Counter{cSubDelReqToE2, 1},
 993                 Counter{cSubDelRespFromE2, 1},
 994                 Counter{cSubDelRespToXapp, 1},
 995         })
 996
 997         // Xapp: Send SubsReq
 998         cretrans := xappConn1.SendSubsReq(t, nil, nil)
 999
1000         // E2t: Receive 1st SubsReq
1001         e2termConn1.RecvSubsReq(t)
1002
1003         // E2t: Receive 2nd SubsReq and send SubsResp
1004         crereq, cremsg := e2termConn1.RecvSubsReq(t)
1005         e2termConn1.SendSubsResp(t, crereq, cremsg)
1006
1007         // Xapp: Receive SubsResp
1008         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1009
1010         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1011         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1012         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1013         xappConn1.RecvSubsDelResp(t, deltrans)
1014
1015         // Wait that subs is cleaned
1016         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1017
1018         xappConn1.TestMsgChanEmpty(t)
1019         xappConn2.TestMsgChanEmpty(t)
1020         e2termConn1.TestMsgChanEmpty(t)
1021         mainCtrl.wait_registry_empty(t, 10)
1022
1023         mainCtrl.VerifyCounterValues(t)
1024 }
1025
1026 //-----------------------------------------------------------------------------
1027 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
1028 //
1029 //   stub                          stub
1030 // +-------+     +---------+    +---------+
1031 // | xapp  |     | submgr  |    | e2term  |
1032 // +-------+     +---------+    +---------+
1033 //     |              |              |
1034 //     |  SubReq      |              |
1035 //     |------------->|              |
1036 //     |              |              |
1037 //     |              | SubReq       |
1038 //     |              |------------->|
1039 //     |              |              |
1040 //     |              |              |
1041 //     |              | SubReq       |
1042 //     |              |------------->|
1043 //     |              |              |
1044 //     |              | SubDelReq    |
1045 //     |              |------------->|
1046 //     |              |              |
1047 //     |              |   SubDelResp |
1048 //     |              |<-------------|
1049 //     |              |              |
1050 //
1051 //-----------------------------------------------------------------------------
1052 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
1053         CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
1054
1055         // Init counter check
1056         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1057                 Counter{cSubReqFromXapp, 1},
1058                 Counter{cSubReqToE2, 1},
1059                 Counter{cSubReReqToE2, 1},
1060                 Counter{cSubReqTimerExpiry, 2},
1061                 Counter{cSubDelReqToE2, 1},
1062                 Counter{cSubDelRespFromE2, 1},
1063         })
1064
1065         // Xapp: Send SubsReq
1066         xappConn1.SendSubsReq(t, nil, nil)
1067
1068         // E2t: Receive 1st SubsReq
1069         e2termConn1.RecvSubsReq(t)
1070
1071         // E2t: Receive 2nd SubsReq
1072         e2termConn1.RecvSubsReq(t)
1073
1074         // E2t: Send receive SubsDelReq and send SubsResp
1075         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1076         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1077
1078         // Wait that subs is cleaned
1079         mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 10)
1080
1081         xappConn1.TestMsgChanEmpty(t)
1082         xappConn2.TestMsgChanEmpty(t)
1083         e2termConn1.TestMsgChanEmpty(t)
1084         mainCtrl.wait_registry_empty(t, 10)
1085
1086         mainCtrl.VerifyCounterValues(t)
1087 }
1088
1089 //-----------------------------------------------------------------------------
1090 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
1091 //
1092 //   stub                          stub
1093 // +-------+     +---------+    +---------+
1094 // | xapp  |     | submgr  |    | e2term  |
1095 // +-------+     +---------+    +---------+
1096 //     |              |              |
1097 //     |  SubReq      |              |
1098 //     |------------->|              |
1099 //     |              |              |
1100 //     |              | SubReq       |
1101 //     |              |------------->|
1102 //     |              |              |
1103 //     |              |              |
1104 //     |              | SubReq       |
1105 //     |              |------------->|
1106 //     |              |              |
1107 //     |              | SubDelReq    |
1108 //     |              |------------->|
1109 //     |              |              |
1110 //     |              |              |
1111 //     |              | SubDelReq    |
1112 //     |              |------------->|
1113 //     |              |              |
1114 //     |              |              |
1115 //
1116 //-----------------------------------------------------------------------------
1117
1118 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
1119         CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
1120
1121         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1122                 Counter{cSubReqFromXapp, 1},
1123                 Counter{cSubReqToE2, 1},
1124                 Counter{cSubReReqToE2, 1},
1125                 Counter{cSubReqTimerExpiry, 2},
1126                 Counter{cSubDelReqToE2, 1},
1127                 Counter{cSubDelReReqToE2, 1},
1128                 Counter{cSubDelReqTimerExpiry, 2},
1129         })
1130
1131         // Xapp: Send SubsReq
1132         xappConn1.SendSubsReq(t, nil, nil)
1133
1134         // E2t: Receive 1st SubsReq
1135         e2termConn1.RecvSubsReq(t)
1136
1137         // E2t: Receive 2nd SubsReq
1138         e2termConn1.RecvSubsReq(t)
1139
1140         // E2t: Receive 1st SubsDelReq
1141         e2termConn1.RecvSubsDelReq(t)
1142
1143         // E2t: Receive 2nd SubsDelReq
1144         delreq, _ := e2termConn1.RecvSubsDelReq(t)
1145
1146         // Wait that subs is cleaned
1147         mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 15)
1148
1149         xappConn1.TestMsgChanEmpty(t)
1150         xappConn2.TestMsgChanEmpty(t)
1151         e2termConn1.TestMsgChanEmpty(t)
1152         mainCtrl.wait_registry_empty(t, 10)
1153
1154         mainCtrl.VerifyCounterValues(t)
1155 }
1156
1157 //-----------------------------------------------------------------------------
1158 // TestSubReqSubFailRespInSubmgr
1159 //
1160 //   stub                          stub
1161 // +-------+     +---------+    +---------+
1162 // | xapp  |     | submgr  |    | e2term  |
1163 // +-------+     +---------+    +---------+
1164 //     |              |              |
1165 //     |  SubReq      |              |
1166 //     |------------->|              |
1167 //     |              |              |
1168 //     |              | SubReq       |
1169 //     |              |------------->|
1170 //     |              |              |
1171 //     |              |      SubFail |
1172 //     |              |<-------------|
1173 //     |              |              |
1174 //     |              | SubDelReq    |
1175 //     |              |------------->|
1176 //     |              |              |
1177 //     |              |   SubDelResp |
1178 //     |              |<-------------|
1179 //     |              |              |
1180 //     |      SubFail |              |
1181 //     |<-------------|              |
1182 //     |              |              |
1183 //
1184 //-----------------------------------------------------------------------------
1185
1186 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1187         CaseBegin("TestSubReqSubFailRespInSubmgr start")
1188
1189         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1190                 Counter{cSubReqFromXapp, 1},
1191                 Counter{cSubReqToE2, 1},
1192                 Counter{cSubFailFromE2, 1},
1193                 Counter{cSubFailToXapp, 1},
1194         })
1195
1196         // Xapp: Send SubsReq
1197         cretrans := xappConn1.SendSubsReq(t, nil, nil)
1198
1199         // E2t: Receive SubsReq and send SubsFail (first)
1200         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1201         fparams1 := &teststube2ap.E2StubSubsFailParams{}
1202         fparams1.Set(crereq1)
1203         e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1204
1205         // E2t: Receive SubsDelReq and send SubsDelResp (internal first)
1206         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1207         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1208
1209         // Xapp: Receive SubsFail
1210         e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
1211
1212         // Wait that subs is cleaned
1213         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1214
1215         xappConn1.TestMsgChanEmpty(t)
1216         xappConn2.TestMsgChanEmpty(t)
1217         e2termConn1.TestMsgChanEmpty(t)
1218         mainCtrl.wait_registry_empty(t, 10)
1219
1220         mainCtrl.VerifyCounterValues(t)
1221 }
1222
1223 //-----------------------------------------------------------------------------
1224 // TestSubDelReqRetryInSubmgr
1225 //
1226 //   stub                          stub
1227 // +-------+     +---------+    +---------+
1228 // | xapp  |     | submgr  |    | e2term  |
1229 // +-------+     +---------+    +---------+
1230 //     |              |              |
1231 //     |         [SUBS CREATE]       |
1232 //     |              |              |
1233 //     |              |              |
1234 //     | SubDelReq    |              |
1235 //     |------------->|              |
1236 //     |              |              |
1237 //     |              | SubDelReq    |
1238 //     |              |------------->|
1239 //     |              |              |
1240 //     |              | SubDelReq    |
1241 //     |              |------------->|
1242 //     |              |              |
1243 //     |              |   SubDelResp |
1244 //     |              |<-------------|
1245 //     |              |              |
1246 //     |   SubDelResp |              |
1247 //     |<-------------|              |
1248 //
1249 //-----------------------------------------------------------------------------
1250
1251 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1252
1253         CaseBegin("TestSubDelReqRetryInSubmgr start")
1254
1255         // Subs Create
1256         cretrans := xappConn1.SendSubsReq(t, nil, nil)
1257         crereq, cremsg := e2termConn1.RecvSubsReq(t)
1258         e2termConn1.SendSubsResp(t, crereq, cremsg)
1259         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1260
1261         // Subs Delete
1262         // Xapp: Send SubsDelReq
1263         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1264
1265         // E2t: Receive 1st SubsDelReq
1266         e2termConn1.RecvSubsDelReq(t)
1267
1268         // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1269         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1270         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1271
1272         // Xapp: Receive SubsDelResp
1273         xappConn1.RecvSubsDelResp(t, deltrans)
1274
1275         // Wait that subs is cleaned
1276         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1277
1278         xappConn1.TestMsgChanEmpty(t)
1279         xappConn2.TestMsgChanEmpty(t)
1280         e2termConn1.TestMsgChanEmpty(t)
1281         mainCtrl.wait_registry_empty(t, 10)
1282 }
1283
1284 //-----------------------------------------------------------------------------
1285 // TestSubDelReqTwoRetriesNoRespInSubmgr
1286 //
1287 //   stub                          stub
1288 // +-------+     +---------+    +---------+
1289 // | xapp  |     | submgr  |    | e2term  |
1290 // +-------+     +---------+    +---------+
1291 //     |              |              |
1292 //     |         [SUBS CREATE]       |
1293 //     |              |              |
1294 //     |              |              |
1295 //     | SubDelReq    |              |
1296 //     |------------->|              |
1297 //     |              |              |
1298 //     |              | SubDelReq    |
1299 //     |              |------------->|
1300 //     |              |              |
1301 //     |              | SubDelReq    |
1302 //     |              |------------->|
1303 //     |              |              |
1304 //     |              |              |
1305 //     |   SubDelResp |              |
1306 //     |<-------------|              |
1307 //
1308 //-----------------------------------------------------------------------------
1309
1310 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1311
1312         CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
1313
1314         // Subs Create
1315         cretrans := xappConn1.SendSubsReq(t, nil, nil)
1316         crereq, cremsg := e2termConn1.RecvSubsReq(t)
1317         e2termConn1.SendSubsResp(t, crereq, cremsg)
1318         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1319
1320         // Subs Delete
1321         // Xapp: Send SubsDelReq
1322         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1323
1324         // E2t: Receive 1st SubsDelReq
1325         e2termConn1.RecvSubsDelReq(t)
1326
1327         // E2t: Receive 2nd SubsDelReq
1328         e2termConn1.RecvSubsDelReq(t)
1329
1330         // Xapp: Receive SubsDelResp
1331         xappConn1.RecvSubsDelResp(t, deltrans)
1332
1333         // Wait that subs is cleaned
1334         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1335
1336         xappConn1.TestMsgChanEmpty(t)
1337         xappConn2.TestMsgChanEmpty(t)
1338         e2termConn1.TestMsgChanEmpty(t)
1339         mainCtrl.wait_registry_empty(t, 10)
1340 }
1341
1342 //-----------------------------------------------------------------------------
1343 // TestSubDelReqSubDelFailRespInSubmgr
1344 //
1345 //   stub                          stub
1346 // +-------+     +---------+    +---------+
1347 // | xapp  |     | submgr  |    | e2term  |
1348 // +-------+     +---------+    +---------+
1349 //     |              |              |
1350 //     |         [SUBS CREATE]       |
1351 //     |              |              |
1352 //     |              |              |
1353 //     |  SubDelReq   |              |
1354 //     |------------->|              |
1355 //     |              |              |
1356 //     |              | SubDelReq    |
1357 //     |              |------------->|
1358 //     |              |              |
1359 //     |              |   SubDelFail |
1360 //     |              |<-------------|
1361 //     |              |              |
1362 //     |   SubDelResp |              |
1363 //     |<-------------|              |
1364 //     |              |              |
1365 //
1366 //-----------------------------------------------------------------------------
1367
1368 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1369         CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1370
1371         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1372                 Counter{cSubReqFromXapp, 1},
1373                 Counter{cSubReqToE2, 1},
1374                 Counter{cSubRespFromE2, 1},
1375                 Counter{cSubRespToXapp, 1},
1376                 Counter{cSubDelReqFromXapp, 1},
1377                 Counter{cSubDelReqToE2, 1},
1378                 Counter{cSubDelFailFromE2, 1},
1379                 Counter{cSubDelRespToXapp, 1},
1380         })
1381
1382         // Subs Create
1383         cretrans := xappConn1.SendSubsReq(t, nil, nil)
1384         crereq, cremsg := e2termConn1.RecvSubsReq(t)
1385         e2termConn1.SendSubsResp(t, crereq, cremsg)
1386         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1387
1388         // Xapp: Send SubsDelReq
1389         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1390
1391         // E2t: Send receive SubsDelReq and send SubsDelFail
1392         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1393         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1394
1395         // Xapp: Receive SubsDelResp
1396         xappConn1.RecvSubsDelResp(t, deltrans)
1397
1398         // Wait that subs is cleaned
1399         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1400
1401         xappConn1.TestMsgChanEmpty(t)
1402         xappConn2.TestMsgChanEmpty(t)
1403         e2termConn1.TestMsgChanEmpty(t)
1404         mainCtrl.wait_registry_empty(t, 10)
1405
1406         mainCtrl.VerifyCounterValues(t)
1407 }
1408
1409 //-----------------------------------------------------------------------------
1410 // TestSubReqAndSubDelOkSameAction
1411 //
1412 //   stub                          stub
1413 // +-------+     +-------+     +---------+    +---------+
1414 // | xapp2 |     | xapp1 |     | submgr  |    | e2term  |
1415 // +-------+     +-------+     +---------+    +---------+
1416 //     |             |              |              |
1417 //     |             |              |              |
1418 //     |             |              |              |
1419 //     |             | SubReq1      |              |
1420 //     |             |------------->|              |
1421 //     |             |              |              |
1422 //     |             |              | SubReq1      |
1423 //     |             |              |------------->|
1424 //     |             |              |    SubResp1  |
1425 //     |             |              |<-------------|
1426 //     |             |    SubResp1  |              |
1427 //     |             |<-------------|              |
1428 //     |             |              |              |
1429 //     |          SubReq2           |              |
1430 //     |--------------------------->|              |
1431 //     |             |              |              |
1432 //     |          SubResp2          |              |
1433 //     |<---------------------------|              |
1434 //     |             |              |              |
1435 //     |             | SubDelReq 1  |              |
1436 //     |             |------------->|              |
1437 //     |             |              |              |
1438 //     |             | SubDelResp 1 |              |
1439 //     |             |<-------------|              |
1440 //     |             |              |              |
1441 //     |         SubDelReq 2        |              |
1442 //     |--------------------------->|              |
1443 //     |             |              |              |
1444 //     |             |              | SubDelReq 2  |
1445 //     |             |              |------------->|
1446 //     |             |              |              |
1447 //     |             |              | SubDelReq 2  |
1448 //     |             |              |------------->|
1449 //     |             |              |              |
1450 //     |         SubDelResp 2       |              |
1451 //     |<---------------------------|              |
1452 //
1453 //-----------------------------------------------------------------------------
1454 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
1455         CaseBegin("TestSubReqAndSubDelOkSameAction")
1456
1457         // Init counter check
1458         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1459                 Counter{cSubReqFromXapp, 2},
1460                 Counter{cSubReqToE2, 1},
1461                 Counter{cSubRespFromE2, 1},
1462                 Counter{cSubRespToXapp, 2},
1463                 Counter{cMergedSubscriptions, 1},
1464                 Counter{cUnmergedSubscriptions, 1},
1465                 Counter{cSubDelReqFromXapp, 2},
1466                 Counter{cSubDelReqToE2, 1},
1467                 Counter{cSubDelRespFromE2, 1},
1468                 Counter{cSubDelRespToXapp, 2},
1469         })
1470
1471         //Req1
1472         rparams1 := &teststube2ap.E2StubSubsReqParams{}
1473         rparams1.Init()
1474         cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1475         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1476         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1477         e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1478
1479         //Req2
1480         rparams2 := &teststube2ap.E2StubSubsReqParams{}
1481         rparams2.Init()
1482         cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1483         //crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1484         //e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1485         e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1486
1487         resp, _ := xapp.Subscription.QuerySubscriptions()
1488         assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1489         assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1490         assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
1491
1492         //Del1
1493         deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1494         //e2termConn1.RecvSubsDelReq(t)
1495         //e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1496         xappConn1.RecvSubsDelResp(t, deltrans1)
1497         //Wait that subs is cleaned
1498         //mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1499
1500         //Del2
1501         deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1502         delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1503         e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1504         xappConn2.RecvSubsDelResp(t, deltrans2)
1505         //Wait that subs is cleaned
1506         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1507
1508         xappConn1.TestMsgChanEmpty(t)
1509         xappConn2.TestMsgChanEmpty(t)
1510         e2termConn1.TestMsgChanEmpty(t)
1511         mainCtrl.wait_registry_empty(t, 10)
1512
1513         mainCtrl.VerifyCounterValues(t)
1514 }
1515
1516 //-----------------------------------------------------------------------------
1517 // TestSubReqAndSubDelOkSameActionParallel
1518 //
1519 //   stub          stub                          stub
1520 // +-------+     +-------+     +---------+    +---------+
1521 // | xapp2 |     | xapp1 |     | submgr  |    | e2term  |
1522 // +-------+     +-------+     +---------+    +---------+
1523 //     |             |              |              |
1524 //     |             |              |              |
1525 //     |             |              |              |
1526 //     |             | SubReq1      |              |
1527 //     |             |------------->|              |
1528 //     |             |              |              |
1529 //     |             |              | SubReq1      |
1530 //     |             |              |------------->|
1531 //     |          SubReq2           |              |
1532 //     |--------------------------->|              |
1533 //     |             |              |    SubResp1  |
1534 //     |             |              |<-------------|
1535 //     |             |    SubResp1  |              |
1536 //     |             |<-------------|              |
1537 //     |             |              |              |
1538 //     |          SubResp2          |              |
1539 //     |<---------------------------|              |
1540 //     |             |              |              |
1541 //     |             | SubDelReq 1  |              |
1542 //     |             |------------->|              |
1543 //     |             |              |              |
1544 //     |             | SubDelResp 1 |              |
1545 //     |             |<-------------|              |
1546 //     |             |              |              |
1547 //     |         SubDelReq 2        |              |
1548 //     |--------------------------->|              |
1549 //     |             |              |              |
1550 //     |             |              | SubDelReq 2  |
1551 //     |             |              |------------->|
1552 //     |             |              |              |
1553 //     |             |              | SubDelReq 2  |
1554 //     |             |              |------------->|
1555 //     |             |              |              |
1556 //     |         SubDelResp 2       |              |
1557 //     |<---------------------------|              |
1558 //
1559 //-----------------------------------------------------------------------------
1560 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1561         CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1562
1563         //Req1
1564         rparams1 := &teststube2ap.E2StubSubsReqParams{}
1565         rparams1.Init()
1566         cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1567         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1568
1569         //Req2
1570         rparams2 := &teststube2ap.E2StubSubsReqParams{}
1571         rparams2.Init()
1572         cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1573
1574         //Resp1
1575         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1576         e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1577
1578         //Resp2
1579         e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1580
1581         //Del1
1582         deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1583         xappConn1.RecvSubsDelResp(t, deltrans1)
1584
1585         //Del2
1586         deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1587         delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1588         e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1589         xappConn2.RecvSubsDelResp(t, deltrans2)
1590
1591         //Wait that subs is cleaned
1592         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1593
1594         xappConn1.TestMsgChanEmpty(t)
1595         xappConn2.TestMsgChanEmpty(t)
1596         e2termConn1.TestMsgChanEmpty(t)
1597         mainCtrl.wait_registry_empty(t, 10)
1598 }
1599
1600 //-----------------------------------------------------------------------------
1601 // TestSubReqAndSubDelNokSameActionParallel
1602 //
1603 //   stub          stub                          stub
1604 // +-------+     +-------+     +---------+    +---------+
1605 // | xapp2 |     | xapp1 |     | submgr  |    | e2term  |
1606 // +-------+     +-------+     +---------+    +---------+
1607 //     |             |              |              |
1608 //     |             |              |              |
1609 //     |             |              |              |
1610 //     |             | SubReq1      |              |
1611 //     |             |------------->|              |
1612 //     |             |              |              |
1613 //     |             |              | SubReq1      |
1614 //     |             |              |------------->|
1615 //     |          SubReq2           |              |
1616 //     |--------------------------->|              |
1617 //     |             |              |    SubFail1  |
1618 //     |             |              |<-------------|
1619 //     |             |              |              |
1620 //     |             |              | SubDelReq    |
1621 //     |             |              |------------->|
1622 //     |             |              |   SubDelResp |
1623 //     |             |              |<-------------|
1624 //     |             |              |              |
1625 //     |             |    SubFail1  |              |
1626 //     |             |<-------------|              |
1627 //     |             |              |              |
1628 //     |          SubFail2          |              |
1629 //     |<---------------------------|              |
1630 //
1631 //-----------------------------------------------------------------------------
1632 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1633         CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1634
1635         //Req1
1636         rparams1 := &teststube2ap.E2StubSubsReqParams{}
1637         rparams1.Init()
1638         cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1639
1640         // E2t: Receive SubsReq (first)
1641         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1642
1643         //Req2
1644         rparams2 := &teststube2ap.E2StubSubsReqParams{}
1645         rparams2.Init()
1646         subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1647         cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1648         mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1649
1650         // E2t: send SubsFail (first)
1651         fparams1 := &teststube2ap.E2StubSubsFailParams{}
1652         fparams1.Set(crereq1)
1653         e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1654
1655         // E2t: internal delete
1656         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1657         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1658
1659         //Fail1
1660         e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1661         //Fail2
1662         xappConn2.RecvSubsFail(t, cretrans2)
1663
1664         //Wait that subs is cleaned
1665         mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1666
1667         xappConn1.TestMsgChanEmpty(t)
1668         xappConn2.TestMsgChanEmpty(t)
1669         e2termConn1.TestMsgChanEmpty(t)
1670         mainCtrl.wait_registry_empty(t, 10)
1671 }
1672
1673 //-----------------------------------------------------------------------------
1674 // TestSubReqAndSubDelNoAnswerSameActionParallel
1675 //
1676 //   stub          stub                          stub
1677 // +-------+     +-------+     +---------+    +---------+
1678 // | xapp2 |     | xapp1 |     | submgr  |    | e2term  |
1679 // +-------+     +-------+     +---------+    +---------+
1680 //     |             |              |              |
1681 //     |             |              |              |
1682 //     |             |              |              |
1683 //     |             | SubReq1      |              |
1684 //     |             |------------->|              |
1685 //     |             |              |              |
1686 //     |             |              | SubReq1      |
1687 //     |             |              |------------->|
1688 //     |             | SubReq2      |              |
1689 //     |--------------------------->|              |
1690 //     |             |              |              |
1691 //     |             |              | SubReq1      |
1692 //     |             |              |------------->|
1693 //     |             |              |              |
1694 //     |             |              |              |
1695 //     |             |              | SubDelReq    |
1696 //     |             |              |------------->|
1697 //     |             |              |              |
1698 //     |             |              |   SubDelResp |
1699 //     |             |              |<-------------|
1700 //
1701 //-----------------------------------------------------------------------------
1702 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1703         CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1704
1705         //Req1
1706         rparams1 := &teststube2ap.E2StubSubsReqParams{}
1707         rparams1.Init()
1708         xappConn1.SendSubsReq(t, rparams1, nil)
1709
1710         crereq1, _ := e2termConn1.RecvSubsReq(t)
1711
1712         //Req2
1713         rparams2 := &teststube2ap.E2StubSubsReqParams{}
1714         rparams2.Init()
1715         subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1716         xappConn2.SendSubsReq(t, rparams2, nil)
1717         mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1718
1719         //Req1 (retransmitted)
1720         e2termConn1.RecvSubsReq(t)
1721
1722         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1723         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1724
1725         //Wait that subs is cleaned
1726         mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10)
1727
1728         xappConn1.TestMsgChanEmpty(t)
1729         xappConn2.TestMsgChanEmpty(t)
1730         e2termConn1.TestMsgChanEmpty(t)
1731         mainCtrl.wait_registry_empty(t, 15)
1732 }
1733
1734 //-----------------------------  Policy cases ---------------------------------
1735 //-----------------------------------------------------------------------------
1736 // TestSubReqPolicyAndSubDelOk
1737 //
1738 //   stub                          stub
1739 // +-------+     +---------+    +---------+
1740 // | xapp  |     | submgr  |    | e2term  |
1741 // +-------+     +---------+    +---------+
1742 //     |              |              |
1743 //     | SubReq       |              |
1744 //     |------------->|              |
1745 //     |              |              |
1746 //     |              | SubReq       |
1747 //     |              |------------->|
1748 //     |              |              |
1749 //     |              |      SubResp |
1750 //     |              |<-------------|
1751 //     |              |              |
1752 //     |      SubResp |              |
1753 //     |<-------------|              |
1754 //     |              |              |
1755 //     |              |              |
1756 //     | SubDelReq    |              |
1757 //     |------------->|              |
1758 //     |              |              |
1759 //     |              | SubDelReq    |
1760 //     |              |------------->|
1761 //     |              |              |
1762 //     |              |   SubDelResp |
1763 //     |              |<-------------|
1764 //     |              |              |
1765 //     |   SubDelResp |              |
1766 //     |<-------------|              |
1767 //
1768 //-----------------------------------------------------------------------------
1769 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
1770         CaseBegin("TestSubReqAndSubDelOk")
1771
1772         rparams1 := &teststube2ap.E2StubSubsReqParams{}
1773         rparams1.Init()
1774         rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1775         cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1776
1777         crereq, cremsg := e2termConn1.RecvSubsReq(t)
1778         e2termConn1.SendSubsResp(t, crereq, cremsg)
1779         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1780         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1781         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1782
1783         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1784         xappConn1.RecvSubsDelResp(t, deltrans)
1785
1786         //Wait that subs is cleaned
1787         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1788
1789         xappConn1.TestMsgChanEmpty(t)
1790         xappConn2.TestMsgChanEmpty(t)
1791         e2termConn1.TestMsgChanEmpty(t)
1792         mainCtrl.wait_registry_empty(t, 10)
1793 }
1794
1795 //-----------------------------------------------------------------------------
1796 // TestSubReqPolicyChangeAndSubDelOk
1797 //
1798 //   stub                          stub
1799 // +-------+     +---------+    +---------+
1800 // | xapp  |     | submgr  |    | e2term  |
1801 // +-------+     +---------+    +---------+
1802 //     |              |              |
1803 //     | SubReq       |              |
1804 //     |------------->|              |
1805 //     |              |              |
1806 //     |              | SubReq       |
1807 //     |              |------------->|
1808 //     |              |              |
1809 //     |              |      SubResp |
1810 //     |              |<-------------|
1811 //     |              |              |
1812 //     |      SubResp |              |
1813 //     |<-------------|              |
1814 //     |              |              |
1815 //     | SubReq       |              |
1816 //     |------------->|              |
1817 //     |              |              |
1818 //     |              | SubReq       |
1819 //     |              |------------->|
1820 //     |              |              |
1821 //     |              |      SubResp |
1822 //     |              |<-------------|
1823 //     |              |              |
1824 //     |      SubResp |              |
1825 //     |<-------------|              |
1826 //     |              |              |
1827 //     | SubDelReq    |              |
1828 //     |------------->|              |
1829 //     |              |              |
1830 //     |              | SubDelReq    |
1831 //     |              |------------->|
1832 //     |              |              |
1833 //     |              |   SubDelResp |
1834 //     |              |<-------------|
1835 //     |              |              |
1836 //     |   SubDelResp |              |
1837 //     |<-------------|              |
1838 //
1839 //-----------------------------------------------------------------------------
1840
1841 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
1842         CaseBegin("TestSubReqAndSubDelOk")
1843
1844         rparams1 := &teststube2ap.E2StubSubsReqParams{}
1845         rparams1.Init()
1846         rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1847         cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1848
1849         crereq, cremsg := e2termConn1.RecvSubsReq(t)
1850         e2termConn1.SendSubsResp(t, crereq, cremsg)
1851         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1852
1853         //Policy change
1854         rparams1.Req.RequestId.InstanceId = e2SubsId
1855         rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
1856         xappConn1.SendSubsReq(t, rparams1, cretrans)
1857
1858         crereq, cremsg = e2termConn1.RecvSubsReq(t)
1859         e2termConn1.SendSubsResp(t, crereq, cremsg)
1860         e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1861         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1862         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1863
1864         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1865         xappConn1.RecvSubsDelResp(t, deltrans)
1866
1867         //Wait that subs is cleaned
1868         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1869
1870         xappConn1.TestMsgChanEmpty(t)
1871         xappConn2.TestMsgChanEmpty(t)
1872         e2termConn1.TestMsgChanEmpty(t)
1873         mainCtrl.wait_registry_empty(t, 10)
1874 }
1875
1876 //-----------------------------------------------------------------------------
1877 // TestSubReqAndSubDelOkTwoE2termParallel
1878 //
1879 //   stub                          stub           stub
1880 // +-------+     +---------+    +---------+    +---------+
1881 // | xapp  |     | submgr  |    | e2term1 |    | e2term2 |
1882 // +-------+     +---------+    +---------+    +---------+
1883 //     |              |              |              |
1884 //     |              |              |              |
1885 //     |              |              |              |
1886 //     | SubReq1      |              |              |
1887 //     |------------->|              |              |
1888 //     |              |              |              |
1889 //     |              | SubReq1      |              |
1890 //     |              |------------->|              |
1891 //     |              |              |              |
1892 //     | SubReq2      |              |              |
1893 //     |------------->|              |              |
1894 //     |              |              |              |
1895 //     |              | SubReq2      |              |
1896 //     |              |---------------------------->|
1897 //     |              |              |              |
1898 //     |              |    SubResp1  |              |
1899 //     |              |<-------------|              |
1900 //     |    SubResp1  |              |              |
1901 //     |<-------------|              |              |
1902 //     |              |    SubResp2  |              |
1903 //     |              |<----------------------------|
1904 //     |    SubResp2  |              |              |
1905 //     |<-------------|              |              |
1906 //     |              |              |              |
1907 //     |        [SUBS 1 DELETE]      |              |
1908 //     |              |              |              |
1909 //     |        [SUBS 2 DELETE]      |              |
1910 //     |              |              |              |
1911 //
1912 //-----------------------------------------------------------------------------
1913 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
1914         CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
1915
1916         //Req1
1917         cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1918         xappConn1.SendSubsReq(t, nil, cretrans1)
1919         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1920
1921         cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
1922         xappConn1.SendSubsReq(t, nil, cretrans2)
1923         crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
1924
1925         //Resp1
1926         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1927         e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1928
1929         //Resp2
1930         e2termConn2.SendSubsResp(t, crereq2, cremsg2)
1931         e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1932
1933         //Del1
1934         deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1935         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1936         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1937         xappConn1.RecvSubsDelResp(t, deltrans1)
1938         //Wait that subs is cleaned
1939         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1940
1941         //Del2
1942         deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
1943         delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
1944         e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
1945         xappConn1.RecvSubsDelResp(t, deltrans2)
1946         //Wait that subs is cleaned
1947         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1948
1949         xappConn1.TestMsgChanEmpty(t)
1950         xappConn2.TestMsgChanEmpty(t)
1951         e2termConn1.TestMsgChanEmpty(t)
1952         e2termConn2.TestMsgChanEmpty(t)
1953         mainCtrl.wait_registry_empty(t, 10)
1954 }
1955
1956 //-----------------------------------------------------------------------------
1957 // TestSubReqInsertAndSubDelOk
1958 //
1959 //   stub                          stub
1960 // +-------+     +---------+    +---------+
1961 // | xapp  |     | submgr  |    | e2term  |
1962 // +-------+     +---------+    +---------+
1963 //     |              |              |
1964 //     | SubReq       |              |
1965 //     |------------->|              |
1966 //     |              |              |
1967 //     |              | SubReq       |
1968 //     |              |------------->|
1969 //     |              |              |
1970 //     |              |      SubResp |
1971 //     |              |<-------------|
1972 //     |              |              |
1973 //     |      SubResp |              |
1974 //     |<-------------|              |
1975 //     |              |              |
1976 //     |              |              |
1977 //     | SubDelReq    |              |
1978 //     |------------->|              |
1979 //     |              |              |
1980 //     |              | SubDelReq    |
1981 //     |              |------------->|
1982 //     |              |              |
1983 //     |              |   SubDelResp |
1984 //     |              |<-------------|
1985 //     |              |              |
1986 //     |   SubDelResp |              |
1987 //     |<-------------|              |
1988 //
1989 //-----------------------------------------------------------------------------
1990 func TestSubReqInsertAndSubDelOk(t *testing.T) {
1991         CaseBegin("TestInsertSubReqAndSubDelOk")
1992
1993         rparams1 := &teststube2ap.E2StubSubsReqParams{}
1994         rparams1.Init()
1995         rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeInsert
1996         cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1997
1998         crereq, cremsg := e2termConn1.RecvSubsReq(t)
1999         e2termConn1.SendSubsResp(t, crereq, cremsg)
2000         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2001         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2002         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2003
2004         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2005         xappConn1.RecvSubsDelResp(t, deltrans)
2006
2007         //Wait that subs is cleaned
2008         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2009
2010         xappConn1.TestMsgChanEmpty(t)
2011         xappConn2.TestMsgChanEmpty(t)
2012         e2termConn1.TestMsgChanEmpty(t)
2013         mainCtrl.wait_registry_empty(t, 10)
2014 }
2015
2016 //-----------------------------------------------------------------------------
2017 // TestSubReqRetransmissionWithSameSubIdDiffXid
2018 //
2019 // This case simulates case where xApp restarts and starts sending same
2020 // subscription requests which have already subscribed successfully
2021
2022 //   stub                          stub
2023 // +-------+     +---------+    +---------+
2024 // | xapp  |     | submgr  |    | e2term  |
2025 // +-------+     +---------+    +---------+
2026 //     |              |              |
2027 //     |  SubReq      |              |
2028 //     |------------->|              |
2029 //     |              |              |
2030 //     |              | SubReq       |
2031 //     |              |------------->|
2032 //     |              |              |
2033 //     |              |      SubResp |
2034 //     |              |<-------------|
2035 //     |              |              |
2036 //     |      SubResp |              |
2037 //     |<-------------|              |
2038 //     |              |              |
2039 //     | xApp restart |              |
2040 //     |              |              |
2041 //     |  SubReq      |              |
2042 //     | (retrans with same xApp generated subid but diff xid)
2043 //     |------------->|              |
2044 //     |              |              |
2045 //     |      SubResp |              |
2046 //     |<-------------|              |
2047 //     |              |              |
2048 //     |         [SUBS DELETE]       |
2049 //     |              |              |
2050 //
2051 //-----------------------------------------------------------------------------
2052 func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) {
2053         CaseBegin("TestSubReqRetransmissionWithSameSubIdDiffXid")
2054
2055         //Subs Create
2056         cretrans := xappConn1.SendSubsReq(t, nil, nil)
2057         crereq, cremsg := e2termConn1.RecvSubsReq(t)
2058         e2termConn1.SendSubsResp(t, crereq, cremsg)
2059         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2060
2061         // xApp restart here
2062         // --> artificial delay
2063         <-time.After(1 * time.Second)
2064
2065         //Subs Create
2066         cretrans = xappConn1.SendSubsReq(t, nil, nil) //Retransmitted SubReq
2067         e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2068
2069         //Subs Delete
2070         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2071         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2072         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2073         xappConn1.RecvSubsDelResp(t, deltrans)
2074
2075         //Wait that subs is cleaned
2076         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2077
2078         xappConn1.TestMsgChanEmpty(t)
2079         xappConn2.TestMsgChanEmpty(t)
2080         e2termConn1.TestMsgChanEmpty(t)
2081         mainCtrl.wait_registry_empty(t, 10)
2082 }
2083
2084 //-----------------------------------------------------------------------------
2085 // TestSubReqNokAndSubDelOkWithRestartInMiddle
2086 //
2087 //   stub                          stub
2088 // +-------+     +---------+    +---------+
2089 // | xapp  |     | submgr  |    | e2term  |
2090 // +-------+     +---------+    +---------+
2091 //     |              |              |
2092 //     | SubReq       |              |
2093 //     |------------->|              |
2094 //     |              |              |
2095 //     |              | SubReq       |
2096 //     |              |------------->|
2097 //     |              |              |
2098 //     |              |      SubResp |
2099 //     |                        <----|
2100 //     |                             |
2101 //     |        Submgr restart       |
2102 //     |                             |
2103 //     |              |              |
2104 //     |              | SubDelReq    |
2105 //     |              |------------->|
2106 //     |              |              |
2107 //     |              |   SubDelResp |
2108 //     |              |<-------------|
2109 //     |              |              |
2110 //
2111 //-----------------------------------------------------------------------------
2112
2113 func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
2114         CaseBegin("TestSubReqNokAndSubDelOkWithRestartInMiddle")
2115
2116         // Remove possible existing subscrition
2117         mainCtrl.removeExistingSubscriptions(t)
2118
2119         mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
2120         xappConn1.SendSubsReq(t, nil, nil)
2121         e2termConn1.RecvSubsReq(t)
2122         mainCtrl.SetResetTestFlag(t, false)
2123
2124         resp, _ := xapp.Subscription.QuerySubscriptions()
2125         assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2126         assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2127         e2SubsId := uint32(resp[0].SubscriptionID)
2128         t.Logf("e2SubsId = %v", e2SubsId)
2129
2130         mainCtrl.SimulateRestart(t)
2131         xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2132
2133         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2134         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2135
2136         // Wait that subs is cleaned
2137         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2138
2139         xappConn1.TestMsgChanEmpty(t)
2140         xappConn2.TestMsgChanEmpty(t)
2141         e2termConn1.TestMsgChanEmpty(t)
2142         mainCtrl.wait_registry_empty(t, 10)
2143 }
2144
2145 //-----------------------------------------------------------------------------
2146 // TestSubReqAndSubDelOkWithRestartInMiddle
2147 //
2148 //   stub                          stub
2149 // +-------+     +---------+    +---------+
2150 // | xapp  |     | submgr  |    | e2term  |
2151 // +-------+     +---------+    +---------+
2152 //     |              |              |
2153 //     | SubReq       |              |
2154 //     |------------->|              |
2155 //     |              |              |
2156 //     |              | SubReq       |
2157 //     |              |------------->|
2158 //     |              |              |
2159 //     |              |      SubResp |
2160 //     |              |<-------------|
2161 //     |              |              |
2162 //     |      SubResp |              |
2163 //     |<-------------|              |
2164 //     |              |              |
2165 //     |                             |
2166 //     |        Submgr restart       |
2167 //     |                             |
2168 //     | SubDelReq    |              |
2169 //     |------------->|              |
2170 //     |              |              |
2171 //     |              | SubDelReq    |
2172 //     |              |------------->|
2173 //     |              |              |
2174 //     |              |   SubDelResp |
2175 //     |              |<-------------|
2176 //     |              |              |
2177 //     |   SubDelResp |              |
2178 //     |<-------------|              |
2179 //
2180 //-----------------------------------------------------------------------------
2181
2182 func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
2183         CaseBegin("TestSubReqAndSubDelOkWithRestartInMiddle")
2184
2185         cretrans := xappConn1.SendSubsReq(t, nil, nil)
2186         crereq, cremsg := e2termConn1.RecvSubsReq(t)
2187         e2termConn1.SendSubsResp(t, crereq, cremsg)
2188         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2189
2190         // Check subscription
2191         resp, _ := xapp.Subscription.QuerySubscriptions()
2192         assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2193         assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2194         assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2195
2196         mainCtrl.SimulateRestart(t)
2197         xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2198
2199         // Check that subscription is restored correctly after restart
2200         resp, _ = xapp.Subscription.QuerySubscriptions()
2201         assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2202         assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2203         assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2204
2205         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2206         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2207         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2208         xappConn1.RecvSubsDelResp(t, deltrans)
2209
2210         //Wait that subs is cleaned
2211         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2212
2213         xappConn1.TestMsgChanEmpty(t)
2214         xappConn2.TestMsgChanEmpty(t)
2215         e2termConn1.TestMsgChanEmpty(t)
2216         mainCtrl.wait_registry_empty(t, 10)
2217 }
2218
2219 //-----------------------------------------------------------------------------
2220 // TestSubReqAndSubDelOkSameActionWithRestartsInMiddle
2221 //
2222 //   stub                          stub
2223 // +-------+     +-------+     +---------+    +---------+
2224 // | xapp2 |     | xapp1 |     | submgr  |    | e2term  |
2225 // +-------+     +-------+     +---------+    +---------+
2226 //     |             |              |              |
2227 //     |             |              |              |
2228 //     |             |              |              |
2229 //     |             | SubReq1      |              |
2230 //     |             |------------->|              |
2231 //     |             |              |              |
2232 //     |             |              | SubReq1      |
2233 //     |             |              |------------->|
2234 //     |             |              |    SubResp1  |
2235 //     |             |              |<-------------|
2236 //     |             |    SubResp1  |              |
2237 //     |             |<-------------|              |
2238 //     |             |              |              |
2239 //     |                                           |
2240 //     |              submgr restart               |
2241 //     |                                           |
2242 //     |             |              |              |
2243 //     |             |              |              |
2244 //     |          SubReq2           |              |
2245 //     |--------------------------->|              |
2246 //     |             |              |              |
2247 //     |          SubResp2          |              |
2248 //     |<---------------------------|              |
2249 //     |             |              |              |
2250 //     |             | SubDelReq 1  |              |
2251 //     |             |------------->|              |
2252 //     |             |              |              |
2253 //     |             | SubDelResp 1 |              |
2254 //     |             |<-------------|              |
2255 //     |             |              |              |
2256 //     |             |              |              |
2257 //     |                                           |
2258 //     |              submgr restart               |
2259 //     |                                           |
2260 //     |             |              |              |
2261 //     |         SubDelReq 2        |              |
2262 //     |--------------------------->|              |
2263 //     |             |              |              |
2264 //     |             |              | SubDelReq 2  |
2265 //     |             |              |------------->|
2266 //     |             |              |              |
2267 //     |             |              | SubDelReq 2  |
2268 //     |             |              |------------->|
2269 //     |             |              |              |
2270 //     |         SubDelResp 2       |              |
2271 //     |<---------------------------|              |
2272 //
2273 //-----------------------------------------------------------------------------
2274
2275 func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
2276         CaseBegin("TestSubReqAndSubDelOkSameActionWithRestartsInMiddle")
2277
2278         //Req1
2279         rparams1 := &teststube2ap.E2StubSubsReqParams{}
2280         rparams1.Init()
2281         cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2282         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2283         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2284         e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2285
2286         //Req2
2287         rparams2 := &teststube2ap.E2StubSubsReqParams{}
2288         rparams2.Init()
2289         cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2290         e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
2291
2292         // Check subscription
2293         resp, _ := xapp.Subscription.QuerySubscriptions() ////////////////////////////////
2294         assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2295         assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2296         assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2297
2298         mainCtrl.SimulateRestart(t)
2299         xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2300
2301         // Check that subscription is restored correctly after restart
2302         resp, _ = xapp.Subscription.QuerySubscriptions()
2303         assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2304         assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2305         assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2306
2307         //Del1
2308         deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2309         xapp.Logger.Debug("xappConn1.RecvSubsDelResp")
2310         xappConn1.RecvSubsDelResp(t, deltrans1)
2311         xapp.Logger.Debug("xappConn1.RecvSubsDelResp received")
2312
2313         mainCtrl.SimulateRestart(t)
2314         xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2315
2316         //Del2
2317         deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
2318         delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2319
2320         e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2321         xappConn2.RecvSubsDelResp(t, deltrans2)
2322
2323         //Wait that subs is cleaned
2324         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2325
2326         xappConn1.TestMsgChanEmpty(t)
2327         xappConn2.TestMsgChanEmpty(t)
2328         e2termConn1.TestMsgChanEmpty(t)
2329         mainCtrl.wait_registry_empty(t, 10)
2330 }
2331
2332 //*****************************************************************************
2333 //  REST interface test cases
2334 //*****************************************************************************
2335
2336 //-----------------------------------------------------------------------------
2337 // Test debug GET and POST requests
2338 //
2339 //   curl
2340 // +-------+     +---------+
2341 // | user  |     | submgr  |
2342 // +-------+     +---------+
2343 //     |              |
2344 //     | GET/POST Req |
2345 //     |------------->|
2346 //     |         Resp |
2347 //     |<-------------|
2348 //     |              |
2349 func TestGetSubscriptions(t *testing.T) {
2350
2351         mainCtrl.sendGetRequest(t, "localhost:8088", "/ric/v1/subscriptions")
2352 }
2353
2354 func TestGetSymptomData(t *testing.T) {
2355
2356         mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/symptomdata")
2357 }
2358
2359 func TestPostdeleteSubId(t *testing.T) {
2360
2361         mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/deletesubid=1")
2362 }
2363
2364 func TestPostEmptyDb(t *testing.T) {
2365
2366         mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/emptydb")
2367 }
2368
2369 //-----------------------------------------------------------------------------
2370 // TestRESTSubReqAndRouteNok
2371 //
2372 //   stub                             stub
2373 // +-------+        +---------+    +---------+
2374 // | xapp  |        | submgr  |    | rtmgr   |
2375 // +-------+        +---------+    +---------+
2376 //     |                 |              |
2377 //     | RESTSubReq      |              |
2378 //     |---------------->|              |
2379 //     |                 |              |
2380 //     |     RESTSubResp |              |
2381 //     |<----------------|              |
2382 //     |                 | RouteCreate  |
2383 //     |                 |------------->|
2384 //     |                 |              |
2385 //     |                 | RouteCreate  |
2386 //     |                 |  status:400  |
2387 //     |                 |(Bad request) |
2388 //     |                 |<-------------|
2389 //     |       RESTNotif |              |
2390 //     |<----------------|              |
2391 //     |                 |              |
2392 //     |          [SUBS INT DELETE]     |
2393 //     |                 |              |
2394 //     | RESTSubDelReq   |              |
2395 //     |---------------->|              |
2396 //     |  RESTSubDelResp |              |
2397 //     |<----------------|              |
2398 //
2399 //-----------------------------------------------------------------------------
2400 func TestRESTSubReqAndRouteNok(t *testing.T) {
2401         CaseBegin("TestRESTSubReqAndRouteNok")
2402
2403         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2404                 Counter{cRestSubReqFromXapp, 1},
2405                 Counter{cRouteCreateFail, 1},
2406                 Counter{cRestSubFailToXapp, 1},
2407                 Counter{cRestSubDelReqFromXapp, 1},
2408                 Counter{cRestSubDelRespToXapp, 1},
2409         })
2410
2411         const subReqCount int = 1
2412         // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
2413         waiter := rtmgrHttp.AllocNextSleep(50, false)
2414         newSubsId := mainCtrl.get_registry_next_subid(t)
2415
2416         // Req
2417         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2418         restSubId := xappConn1.SendRESTSubsReq(t, params)
2419         xappConn1.ExpectRESTNotification(t, restSubId)
2420         waiter.WaitResult(t)
2421
2422         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2423         xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
2424
2425         // Del
2426         xappConn1.SendRESTSubsDelReq(t, &restSubId)
2427
2428         // Wait that subs is cleaned
2429         mainCtrl.wait_subs_clean(t, newSubsId, 10)
2430         waitSubsCleanup(t, e2SubsId, 10)
2431         mainCtrl.VerifyCounterValues(t)
2432 }
2433
2434 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
2435         CaseBegin("TestSubReqAndRouteUpdateNok")
2436
2437         //Init counter check
2438         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2439                 Counter{cRestSubReqFromXapp, 2},
2440                 Counter{cSubReqToE2, 1},
2441                 Counter{cSubRespFromE2, 1},
2442                 Counter{cRestSubRespToXapp, 1},
2443                 Counter{cRestSubFailToXapp, 1},
2444                 Counter{cRouteCreateUpdateFail, 1},
2445                 Counter{cRestSubDelReqFromXapp, 1},
2446                 Counter{cSubDelReqToE2, 1},
2447                 Counter{cSubDelRespFromE2, 1},
2448                 Counter{cRestSubDelRespToXapp, 1},
2449         })
2450
2451         var params *teststube2ap.RESTSubsReqParams = nil
2452
2453         //Subs Create
2454         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2455
2456         queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2457
2458         // xapp2 ROUTE creation shall fail with  400 from rtmgr -> submgr
2459         waiter := rtmgrHttp.AllocNextEvent(false)
2460         newSubsId := mainCtrl.get_registry_next_subid(t)
2461         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
2462         params.SetMeid("RAN_NAME_1")
2463         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2464         xapp.Logger.Info("Send REST subscriber request for second subscriber : %v", restSubId2)
2465         xappConn2.ExpectRESTNotification(t, restSubId2)
2466         waiter.WaitResult(t)
2467         // e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) - TOD: missing delete
2468         xappConn2.WaitRESTNotification(t, restSubId2)
2469
2470         queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2471
2472         deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2473
2474         mainCtrl.wait_subs_clean(t, newSubsId, 10)
2475         //Wait that subs is cleaned
2476         waitSubsCleanup(t, e2SubsId, 10)
2477
2478         mainCtrl.VerifyCounterValues(t)
2479 }
2480
2481 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
2482         CaseBegin("TestRESTSubDelReqAndRouteDeleteNok")
2483
2484         // Init counter check
2485         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2486                 Counter{cRestSubReqFromXapp, 1},
2487                 Counter{cSubReqToE2, 1},
2488                 Counter{cSubRespFromE2, 1},
2489                 Counter{cRestSubRespToXapp, 1},
2490                 Counter{cRestSubDelReqFromXapp, 1},
2491                 Counter{cRouteDeleteFail, 1},
2492                 Counter{cSubDelReqToE2, 1},
2493                 Counter{cSubDelRespFromE2, 1},
2494                 Counter{cRestSubDelRespToXapp, 1},
2495         })
2496
2497         var params *teststube2ap.RESTSubsReqParams = nil
2498
2499         //Subs Create
2500         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2501
2502         queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2503
2504         waiter := rtmgrHttp.AllocNextEvent(false)
2505         xappConn1.SendRESTSubsDelReq(t, &restSubId)
2506         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2507         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2508         waiter.WaitResult(t)
2509
2510         waitSubsCleanup(t, e2SubsId, 10)
2511
2512         mainCtrl.VerifyCounterValues(t)
2513 }
2514
2515 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
2516         CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok")
2517
2518         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2519                 Counter{cRestSubReqFromXapp, 2},
2520                 Counter{cSubReqToE2, 1},
2521                 Counter{cSubRespFromE2, 1},
2522                 Counter{cRestSubRespToXapp, 2},
2523                 Counter{cRestSubDelReqFromXapp, 2},
2524                 Counter{cRouteDeleteUpdateFail, 1},
2525                 Counter{cSubDelReqToE2, 1},
2526                 Counter{cSubDelRespFromE2, 1},
2527                 Counter{cRestSubDelRespToXapp, 2},
2528         })
2529
2530         var params *teststube2ap.RESTSubsReqParams = nil
2531
2532         //Subs Create
2533         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2534
2535         queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2536         restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1")
2537
2538         queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
2539
2540         //Del1, this shall fail on rtmgr side
2541         waiter := rtmgrHttp.AllocNextEvent(false)
2542         xappConn1.SendRESTSubsDelReq(t, &restSubId)
2543         waiter.WaitResult(t)
2544
2545         queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"})
2546
2547         //Del2
2548         deleteXapp2Subscription(t, &restSubId2)
2549
2550         waitSubsCleanup(t, e2SubsId2, 10)
2551
2552         mainCtrl.VerifyCounterValues(t)
2553 }
2554
2555 //-----------------------------------------------------------------------------
2556 // TestRESTSubReqRetransmission
2557 //
2558 //   stub                             stub
2559 // +-------+        +---------+    +---------+
2560 // | xapp  |        | submgr  |    | e2term  |
2561 // +-------+        +---------+    +---------+
2562 //     |                 |              |
2563 //     | RESTSubReq1     |              |
2564 //     |---------------->|              |
2565 //     |                 |              |
2566 //     |     RESTSubResp |              |
2567 //     |<----------------|              |
2568 //     |                 | SubReq1      |
2569 //     |                 |------------->|
2570 //     |                 |              |
2571 //     | RESTSubReq2     |              |
2572 //     | (retrans)       |              |
2573 //     |---------------->|              |
2574 //     |                 |              |
2575 //     |                 | SubReq2      |
2576 //     |                 |------------->|
2577 //     |    RESTSubResp2 |              |
2578 //     |<----------------|              |
2579 //     |                 |     SubResp1 |
2580 //     |                 |<-------------|
2581 //     |      RESTNotif1 |              |
2582 //     |<----------------|              |
2583 //     |                 |     SubResp1 |
2584 //     |                 |<-------------|
2585 //     |      RESTNotif2 |              |
2586 //     |<----------------|              |
2587 //     |                 |              |
2588 //     |            [SUBS DELETE]       |
2589 //     |                 |              |
2590 //
2591 //-----------------------------------------------------------------------------
2592
2593 func TestRESTSubReqRetransmission(t *testing.T) {
2594         CaseBegin("TestRESTSubReqRetransmission")
2595
2596         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2597                 Counter{cRestSubReqFromXapp, 2},
2598                 Counter{cSubReqToE2, 2},
2599                 Counter{cSubRespFromE2, 2},
2600                 Counter{cRestSubRespToXapp, 2},
2601                 Counter{cRestSubDelReqFromXapp, 2},
2602                 Counter{cSubDelReqToE2, 2},
2603                 Counter{cSubDelRespFromE2, 2},
2604                 Counter{cRestSubDelRespToXapp, 2},
2605         })
2606         // Retry/duplicate will get the same way as the first request.  Submgr cannot detect duplicate RESTRequests
2607         // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
2608         // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
2609
2610         // Subs Create
2611         const subReqCount int = 1
2612
2613         // In order to force both XAPP's to create their own subscriptions, force rtmgr to block a while so that 2nd create
2614         // gets into execution before the rtmgrg responds for the first one.
2615         waiter := rtmgrHttp.AllocNextSleep(10, true)
2616         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2617         restSubId1 := xappConn1.SendRESTSubsReq(t, params)
2618         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2619
2620         waiter.WaitResult(t)
2621
2622         xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
2623
2624         // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
2625         // the order is not significant he6re.
2626         crereq, cremsg := e2termConn1.RecvSubsReq(t)
2627         e2termConn1.SendSubsResp(t, crereq, cremsg)
2628         crereq, cremsg = e2termConn1.RecvSubsReq(t)
2629         e2termConn1.SendSubsResp(t, crereq, cremsg)
2630
2631         e2SubsIdA := <-xappConn1.ListedRESTNotifications
2632         xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
2633         e2SubsIdB := <-xappConn1.ListedRESTNotifications
2634         xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
2635
2636         // Del1
2637         xappConn1.SendRESTSubsDelReq(t, &restSubId1)
2638         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2639         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2640
2641         // Del2
2642         xappConn2.SendRESTSubsDelReq(t, &restSubId2)
2643         delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2644         e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2645
2646         mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
2647
2648         waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
2649
2650         mainCtrl.VerifyCounterValues(t)
2651 }
2652
2653 func TestRESTSubDelReqRetransmission(t *testing.T) {
2654         CaseBegin("TestRESTSubDelReqRetransmission")
2655
2656         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2657                 Counter{cRestSubReqFromXapp, 1},
2658                 Counter{cSubReqToE2, 1},
2659                 Counter{cSubRespFromE2, 1},
2660                 Counter{cRestSubRespToXapp, 1},
2661                 Counter{cRestSubDelReqFromXapp, 2},
2662                 Counter{cSubDelReqToE2, 1},
2663                 Counter{cSubDelRespFromE2, 1},
2664                 Counter{cRestSubDelRespToXapp, 1},
2665         })
2666
2667         var params *teststube2ap.RESTSubsReqParams = nil
2668
2669         //Subs Create
2670         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2671
2672         queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2673
2674         //Subs Delete
2675         xappConn1.SendRESTSubsDelReq(t, &restSubId)
2676         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2677
2678         seqBef := mainCtrl.get_msgcounter(t)
2679         xappConn1.SendRESTSubsDelReq(t, &restSubId)
2680         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
2681
2682         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2683
2684         waitSubsCleanup(t, e2SubsId, 10)
2685
2686         mainCtrl.VerifyCounterValues(t)
2687 }
2688
2689 //-----------------------------------------------------------------------------
2690 // TestRESTSubReqDelReq
2691 //
2692 //   stub                             stub
2693 // +-------+        +---------+    +---------+
2694 // | xapp  |        | submgr  |    | e2term  |
2695 // +-------+        +---------+    +---------+
2696 //     |                 |              |
2697 //     | RESTSubReq      |              |
2698 //     |---------------->|              |
2699 //     |                 |              |
2700 //     |     RESTSubResp |              |
2701 //     |<----------------|              |
2702 //     |                 | SubReq       |
2703 //     |                 |------------->|
2704 //     | RESTSubDelReq   |              |
2705 //     |---------------->|              |
2706 //     |  RESTSubDelResp |              |
2707 //     |     unsuccess   |              |
2708 //     |<----------------|              |
2709 //     |                 |      SubResp |
2710 //     |                 |<-------------|
2711 //     |      RESTNotif1 |              |
2712 //     |<----------------|              |
2713 //     |                 |              |
2714 //     |            [SUBS DELETE]       |
2715 //     |                 |              |
2716 //
2717 //-----------------------------------------------------------------------------
2718 func TestRESTSubReqDelReq(t *testing.T) {
2719         CaseBegin("TestRESTSubReqDelReq")
2720
2721         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2722                 Counter{cRestSubReqFromXapp, 1},
2723                 Counter{cSubReqToE2, 1},
2724                 Counter{cSubRespFromE2, 1},
2725                 Counter{cRestSubRespToXapp, 1},
2726                 Counter{cRestSubDelReqFromXapp, 2},
2727                 Counter{cSubDelReqToE2, 1},
2728                 Counter{cSubDelRespFromE2, 1},
2729                 Counter{cRestSubDelRespToXapp, 1},
2730         })
2731
2732         const subReqCount int = 1
2733
2734         // Req
2735         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2736         restSubId := xappConn1.SendRESTSubsReq(t, params)
2737
2738         // Del. This will fail as processing of the subscription
2739         // is still ongoing in submgr. Deletion is not allowed before
2740         // subscription creation has been completed.
2741         xappConn1.SendRESTSubsDelReq(t, &restSubId)
2742         crereq, cremsg := e2termConn1.RecvSubsReq(t)
2743         xappConn1.ExpectRESTNotification(t, restSubId)
2744         e2termConn1.SendSubsResp(t, crereq, cremsg)
2745         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2746
2747         // Retry del
2748         xappConn1.SendRESTSubsDelReq(t, &restSubId)
2749
2750         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2751         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2752
2753         // Wait that subs is cleaned
2754         waitSubsCleanup(t, e2SubsId, 10)
2755         mainCtrl.VerifyCounterValues(t)
2756
2757 }
2758
2759 func TestRESTSubDelReqCollision(t *testing.T) {
2760         CaseBegin("TestRESTSubDelReqCollision - not relevant for REST API")
2761 }
2762
2763 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
2764         CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel")
2765
2766         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2767                 Counter{cRestSubReqFromXapp, 2},
2768                 Counter{cSubReqToE2, 2},
2769                 Counter{cSubRespFromE2, 2},
2770                 Counter{cRestSubRespToXapp, 2},
2771                 Counter{cRestSubDelReqFromXapp, 2},
2772                 Counter{cSubDelReqToE2, 2},
2773                 Counter{cSubDelRespFromE2, 2},
2774                 Counter{cRestSubDelRespToXapp, 2},
2775         })
2776
2777         //Req1
2778         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2779         restSubId1 := xappConn1.SendRESTSubsReq(t, params)
2780         xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
2781
2782         //Req2
2783         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
2784         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2785         xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
2786
2787         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2788         crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
2789
2790         //XappConn1 receives both of the  responses
2791         xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
2792
2793         //Resp1
2794         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2795         //Resp2
2796         e2termConn1.SendSubsResp(t, crereq2, cremsg2)
2797
2798         e2SubsIdA := <-xappConn1.ListedRESTNotifications
2799         xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
2800         e2SubsIdB := <-xappConn1.ListedRESTNotifications
2801         xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
2802
2803         //Del1
2804         deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
2805         //Del2
2806         deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
2807
2808         //Wait that subs is cleaned
2809         mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
2810         waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
2811
2812         mainCtrl.VerifyCounterValues(t)
2813
2814 }
2815
2816 func TestRESTSameSubsDiffRan(t *testing.T) {
2817         CaseBegin("TestRESTSameSubsDiffRan")
2818
2819         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2820                 Counter{cRestSubReqFromXapp, 2},
2821                 Counter{cSubReqToE2, 2},
2822                 Counter{cSubRespFromE2, 2},
2823                 Counter{cRestSubRespToXapp, 2},
2824                 Counter{cRestSubDelReqFromXapp, 2},
2825                 Counter{cSubDelReqToE2, 2},
2826                 Counter{cSubDelRespFromE2, 2},
2827                 Counter{cRestSubDelRespToXapp, 2},
2828         })
2829
2830         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2831         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
2832         xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
2833
2834         params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
2835         params.SetMeid("RAN_NAME_2")
2836         restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
2837         xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
2838
2839         //Del1
2840         deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
2841         //Del2
2842         deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
2843
2844         //Wait that subs is cleaned
2845         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
2846         waitSubsCleanup(t, e2SubsId2, 10)
2847
2848         mainCtrl.VerifyCounterValues(t)
2849
2850 }
2851
2852 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
2853         CaseBegin("TestRESTSubReqRetryInSubmgr start")
2854
2855         // Init counter check
2856         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2857                 Counter{cRestSubReqFromXapp, 1},
2858                 Counter{cSubReqToE2, 1},
2859                 Counter{cSubReReqToE2, 1},
2860                 Counter{cSubRespFromE2, 1},
2861                 Counter{cRestSubRespToXapp, 1},
2862                 Counter{cRestSubDelReqFromXapp, 1},
2863                 Counter{cSubDelReqToE2, 1},
2864                 Counter{cSubDelRespFromE2, 1},
2865                 Counter{cRestSubDelRespToXapp, 1},
2866         })
2867
2868         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2869         restSubId := xappConn1.SendRESTSubsReq(t, params)
2870
2871         xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
2872
2873         // Catch the first message and ignore it
2874         crereq, cremsg := e2termConn1.RecvSubsReq(t)
2875         xapp.Logger.Info("Ignore REST subscriber request for subscriber : %v", restSubId)
2876
2877         // The second request is being handled normally
2878         crereq, cremsg = e2termConn1.RecvSubsReq(t)
2879         xappConn1.ExpectRESTNotification(t, restSubId)
2880         e2termConn1.SendSubsResp(t, crereq, cremsg)
2881         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2882
2883         queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2884
2885         deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2886
2887         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2888         //Wait that subs is cleaned
2889         waitSubsCleanup(t, e2SubsId, 10)
2890
2891         mainCtrl.VerifyCounterValues(t)
2892
2893 }
2894
2895 //-----------------------------------------------------------------------------
2896 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
2897 //
2898 //   stub                             stub
2899 // +-------+        +---------+    +---------+
2900 // | xapp  |        | submgr  |    | e2term  |
2901 // +-------+        +---------+    +---------+
2902 //     |                 |              |
2903 //     | RESTSubReq      |              |
2904 //     |---------------->|              |
2905 //     |                 |              |
2906 //     |     RESTSubResp |              |
2907 //     |<----------------|              |
2908 //     |                 | SubReq       |
2909 //     |                 |------------->|
2910 //     |                 |              |
2911 //     |                 |              |
2912 //     |                 | SubReq       |
2913 //     |                 |------------->|
2914 //     |                 |              |
2915 //     |                 | SubDelReq    |
2916 //     |                 |------------->|
2917 //     |                 |              |
2918 //     |                 |              |
2919 //     |                 | SubDelReq    |
2920 //     |                 |------------->|
2921 //     |                 |              |
2922 //     |                 |              |
2923 //     |                 |   SubDelResp |
2924 //     |                 |<-------------|
2925 //     |       RESTNotif |              |
2926 //     |       unsuccess |              |
2927 //     |<----------------|              |
2928 //     |                 |              |
2929 //     |            [SUBS DELETE]       |
2930 //     |                 |              |
2931 //
2932 //-----------------------------------------------------------------------------
2933 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
2934         CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
2935
2936         // Init counter check
2937         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2938                 Counter{cRestSubReqFromXapp, 1},
2939                 Counter{cSubReqToE2, 1},
2940                 Counter{cSubReReqToE2, 1},
2941                 Counter{cSubReqTimerExpiry, 2},
2942                 Counter{cSubDelReqToE2, 1},
2943                 Counter{cSubDelRespFromE2, 1},
2944         })
2945
2946         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2947         restSubId := xappConn1.SendRESTSubsReq(t, params)
2948         xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
2949
2950         e2termConn1.RecvSubsReq(t)
2951         xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
2952
2953         e2termConn1.RecvSubsReq(t)
2954         xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
2955
2956         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2957         xappConn1.ExpectRESTNotification(t, restSubId)
2958         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2959         // e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)     - TODO:  Should we delete this?
2960         xappConn1.WaitRESTNotification(t, restSubId)
2961
2962         // Wait that subs is cleaned
2963         waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
2964
2965         mainCtrl.VerifyCounterValues(t)
2966 }
2967
2968 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
2969         CaseBegin("TestREST2eTermNotRespondingToSubReq start")
2970
2971         // Init counter check
2972         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2973                 Counter{cRestSubReqFromXapp, 1},
2974                 Counter{cSubReqToE2, 1},
2975                 Counter{cSubReReqToE2, 1},
2976                 Counter{cSubReqTimerExpiry, 2},
2977                 Counter{cSubDelReqToE2, 1},
2978                 Counter{cSubDelReqTimerExpiry, 2},
2979         })
2980
2981         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2982         restSubId := xappConn1.SendRESTSubsReq(t, params)
2983         xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
2984
2985         e2termConn1.RecvSubsReq(t)
2986         xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
2987
2988         e2termConn1.RecvSubsReq(t)
2989         xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
2990
2991         e2termConn1.RecvSubsDelReq(t)
2992         xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
2993
2994         xappConn1.ExpectRESTNotification(t, restSubId)
2995         e2termConn1.RecvSubsDelReq(t)
2996         xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
2997
2998         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2999
3000         waitSubsCleanup(t, e2SubsId, 10)
3001
3002         mainCtrl.VerifyCounterValues(t)
3003
3004 }
3005
3006 //-----------------------------------------------------------------------------
3007 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3008 //
3009 //   stub                             stub
3010 // +-------+        +---------+    +---------+
3011 // | xapp  |        | submgr  |    | e2term  |
3012 // +-------+        +---------+    +---------+
3013 //     |                 |              |
3014 //     | RESTSubReq      |              |
3015 //     |---------------->|              |
3016 //     |                 |              |
3017 //     |     RESTSubResp |              |
3018 //     |<----------------|              |
3019 //     |                 | SubReq       |
3020 //     |                 |------------->|
3021 //     |                 |              |
3022 //     |                 |              |
3023 //     |                 | SubReq       |
3024 //     |                 |------------->|
3025 //     |                 |              |
3026 //     |                 | SubDelReq    |
3027 //     |                 |------------->|
3028 //     |                 |              |
3029 //     |                 |              |
3030 //     |                 | SubDelReq    |
3031 //     |                 |------------->|
3032 //     |                 |              |
3033 //     |                 |              |
3034 //     |                 |   SubDelResp |
3035 //     |                 |<-------------|
3036 //     |       RESTNotif |              |
3037 //     |       unsuccess |              |
3038 //     |<----------------|              |
3039 //     |                 |              |
3040 //     |            [SUBS DELETE]       |
3041 //     |                 |              |
3042 //
3043 //-----------------------------------------------------------------------------
3044 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
3045         CaseBegin("TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr start")
3046
3047         // Init counter check
3048         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3049                 Counter{cRestSubReqFromXapp, 1},
3050                 Counter{cSubReqToE2, 1},
3051                 Counter{cSubReReqToE2, 1},
3052                 Counter{cSubReqTimerExpiry, 2},
3053                 Counter{cSubDelReqToE2, 1},
3054                 Counter{cSubDelReReqToE2, 1},
3055                 Counter{cSubDelReqTimerExpiry, 2},
3056         })
3057
3058         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3059         restSubId := xappConn1.SendRESTSubsReq(t, params)
3060         xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
3061
3062         e2termConn1.RecvSubsReq(t)
3063         xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3064
3065         e2termConn1.RecvSubsReq(t)
3066         xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3067
3068         e2termConn1.RecvSubsDelReq(t)
3069         xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3070
3071         xappConn1.ExpectRESTNotification(t, restSubId)
3072         e2termConn1.RecvSubsDelReq(t)
3073         xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3074
3075         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3076
3077         waitSubsCleanup(t, e2SubsId, 10)
3078
3079         mainCtrl.VerifyCounterValues(t)
3080 }
3081
3082 //-----------------------------------------------------------------------------
3083 // TestRESTSubReqSubFailRespInSubmgr
3084 //
3085 //   stub                             stub
3086 // +-------+        +---------+    +---------+
3087 // | xapp  |        | submgr  |    | e2term  |
3088 // +-------+        +---------+    +---------+
3089 //     |                 |              |
3090 //     | RESTSubReq      |              |
3091 //     |---------------->|              |
3092 //     |                 |              |
3093 //     |     RESTSubResp |              |
3094 //     |<----------------|              |
3095 //     |                 | SubReq       |
3096 //     |                 |------------->|
3097 //     |                 |              |
3098 //     |                 |      SubFail |
3099 //     |                 |<-------------|
3100 //     |                 |              |
3101 //     |                 | SubDelReq    |
3102 //     |                 |------------->|
3103 //     |                 |              |
3104 //     |                 |   SubDelResp |
3105 //     |                 |<-------------|
3106 //     |                 |              |
3107 //     |       RESTNotif |              |
3108 //     |       unsuccess |              |
3109 //     |<----------------|              |
3110 //     |                 |              |
3111 //     |            [SUBS DELETE]       |
3112 //     |                 |              |
3113 //
3114 //-----------------------------------------------------------------------------
3115 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
3116         CaseBegin("TestRESTSubReqSubFailRespInSubmgr")
3117
3118         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3119                 Counter{cRestSubReqFromXapp, 1},
3120                 Counter{cSubReqToE2, 1},
3121                 Counter{cSubFailFromE2, 1},
3122                 Counter{cRestSubFailToXapp, 1},
3123                 Counter{cRestSubDelReqFromXapp, 1},
3124         })
3125
3126         const subReqCount int = 1
3127
3128         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3129         restSubId := xappConn1.SendRESTSubsReq(t, params)
3130
3131         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3132         fparams1 := &teststube2ap.E2StubSubsFailParams{}
3133         fparams1.Set(crereq1)
3134         e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3135
3136         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3137         xappConn1.ExpectRESTNotification(t, restSubId)
3138         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3139         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3140         xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
3141
3142         // REST subscription sill there to be deleted
3143         xappConn1.SendRESTSubsDelReq(t, &restSubId)
3144
3145         // Wait that subs is cleaned
3146         waitSubsCleanup(t, e2SubsId, 10)
3147
3148         mainCtrl.VerifyCounterValues(t)
3149
3150 }
3151
3152 //-----------------------------------------------------------------------------
3153 // TestRESTSubDelReqRetryInSubmgr
3154 //
3155 //   stub                             stub
3156 // +-------+        +---------+    +---------+
3157 // | xapp  |        | submgr  |    | e2term  |
3158 // +-------+        +---------+    +---------+
3159 //     |                 |              |
3160 //     |            [SUBS CREATE]       |
3161 //     |                 |              |
3162 //     |                 |              |
3163 //     | RESTSubDelReq   |              |
3164 //     |---------------->|              |
3165 //     |                 |              |
3166 //     |  RESTSubDelResp |              |
3167 //     |<----------------|              |
3168 //     |                 | SubDelReq    |
3169 //     |                 |------------->|
3170 //     |                 |              |
3171 //     |                 | SubDelReq    |
3172 //     |                 |------------->|
3173 //     |                 |              |
3174 //     |                 |   SubDelResp |
3175 //     |                 |<-------------|
3176 //     |                 |              |
3177 //
3178 //-----------------------------------------------------------------------------
3179 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
3180         CaseBegin("TestRESTSubDelReqRetryInSubmgr")
3181
3182         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3183                 Counter{cRestSubReqFromXapp, 1},
3184                 Counter{cSubReqToE2, 1},
3185                 Counter{cSubRespFromE2, 1},
3186                 Counter{cRestSubRespToXapp, 1},
3187                 Counter{cRestSubDelReqFromXapp, 1},
3188                 Counter{cSubDelReqToE2, 1},
3189                 Counter{cSubDelReReqToE2, 1},
3190                 Counter{cSubDelRespFromE2, 1},
3191                 Counter{cRestSubDelRespToXapp, 1},
3192         })
3193         // Req
3194         var params *teststube2ap.RESTSubsReqParams = nil
3195         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3196
3197         // Del
3198         xappConn1.SendRESTSubsDelReq(t, &restSubId)
3199
3200         // E2t: Receive 1st SubsDelReq
3201         e2termConn1.RecvSubsDelReq(t)
3202
3203         // E2t: Receive 2nd SubsDelReq and send SubsDelResp
3204         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3205         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3206
3207         //Wait that subs is cleaned
3208         waitSubsCleanup(t, e2SubsId, 10)
3209
3210         mainCtrl.VerifyCounterValues(t)
3211 }
3212
3213 //-----------------------------------------------------------------------------
3214 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
3215 //
3216 //   stub                             stub
3217 // +-------+        +---------+    +---------+
3218 // | xapp  |        | submgr  |    | e2term  |
3219 // +-------+        +---------+    +---------+
3220 //     |                 |              |
3221 //     |            [SUBS CREATE]       |
3222 //     |                 |              |
3223 //     |                 |              |
3224 //     | RESTSubDelReq   |              |
3225 //     |---------------->|              |
3226 //     |                 |              |
3227 //     |  RESTSubDelResp |              |
3228 //     |<----------------|              |
3229 //     |                 | SubDelReq    |
3230 //     |                 |------------->|
3231 //     |                 |              |
3232 //     |                 | SubDelReq    |
3233 //     |                 |------------->|
3234 //     |                 |              |
3235 //     |                 |              |
3236 //
3237 //-----------------------------------------------------------------------------
3238 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
3239         CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr")
3240
3241         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3242                 Counter{cRestSubReqFromXapp, 1},
3243                 Counter{cSubReqToE2, 1},
3244                 Counter{cSubRespFromE2, 1},
3245                 Counter{cRestSubRespToXapp, 1},
3246                 Counter{cRestSubDelReqFromXapp, 1},
3247                 Counter{cSubDelReqToE2, 1},
3248                 Counter{cSubDelReReqToE2, 1},
3249                 Counter{cSubDelRespFromE2, 1},
3250                 Counter{cRestSubDelRespToXapp, 1},
3251         })
3252
3253         // Req
3254         var params *teststube2ap.RESTSubsReqParams = nil
3255         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3256
3257         // Del
3258         xappConn1.SendRESTSubsDelReq(t, &restSubId)
3259
3260         // E2t: Receive 1st SubsDelReq
3261         e2termConn1.RecvSubsDelReq(t)
3262
3263         // E2t: Receive 2nd SubsDelReq and send SubsDelResp
3264         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3265         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3266
3267         //Wait that subs is cleaned
3268         waitSubsCleanup(t, e2SubsId, 10)
3269
3270         mainCtrl.VerifyCounterValues(t)
3271 }
3272
3273 //-----------------------------------------------------------------------------
3274 // TestRESTSubDelReqSubDelFailRespInSubmgr
3275 //
3276 //   stub                             stub
3277 // +-------+        +---------+    +---------+
3278 // | xapp  |        | submgr  |    | e2term  |
3279 // +-------+        +---------+    +---------+
3280 //     |                 |              |
3281 //     |            [SUBS CREATE]       |
3282 //     |                 |              |
3283 //     |                 |              |
3284 //     | RESTSubDelReq   |              |
3285 //     |---------------->|              |
3286 //     |                 |              |
3287 //     |  RESTSubDelResp |              |
3288 //     |<----------------|              |
3289 //     |                 | SubDelReq    |
3290 //     |                 |------------->|
3291 //     |                 |              |
3292 //     |                 |   SubDelFail |
3293 //     |                 |<-------------|
3294 //     |                 |              |
3295 //
3296 //-----------------------------------------------------------------------------
3297 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
3298         CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr")
3299
3300         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3301                 Counter{cRestSubReqFromXapp, 1},
3302                 Counter{cSubReqToE2, 1},
3303                 Counter{cSubRespFromE2, 1},
3304                 Counter{cRestSubRespToXapp, 1},
3305                 Counter{cRestSubDelReqFromXapp, 1},
3306                 Counter{cSubDelReqToE2, 1},
3307                 Counter{cSubDelFailFromE2, 1},
3308                 Counter{cRestSubDelRespToXapp, 1},
3309         })
3310
3311         // Req
3312         var params *teststube2ap.RESTSubsReqParams = nil
3313         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3314
3315         // Del
3316         xappConn1.SendRESTSubsDelReq(t, &restSubId)
3317
3318         // E2t: Send receive SubsDelReq and send SubsDelFail
3319         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3320         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
3321
3322         //Wait that subs is cleaned
3323         waitSubsCleanup(t, e2SubsId, 10)
3324
3325         mainCtrl.VerifyCounterValues(t)
3326 }
3327
3328 //-----------------------------------------------------------------------------
3329 // TestRESTSubReqAndSubDelOkSameAction
3330 //
3331 //   stub                             stub
3332 // +-------+     +-------+        +---------+    +---------+
3333 // | xapp2 |     | xapp1 |        | submgr  |    | e2term  |
3334 // +-------+     +-------+        +---------+    +---------+
3335 //     |             |                 |              |
3336 //     |             | RESTSubReq1     |              |
3337 //     |             |---------------->|              |
3338 //     |             |                 |              |
3339 //     |             |    RESTSubResp1 |              |
3340 //     |             |<----------------|              |
3341 //     |             |                 |              |
3342 //     |             |                 | SubReq1      |
3343 //     |             |                 |------------->|
3344 //     |             |                 |    SubResp1  |
3345 //     |             |                 |<-------------|
3346 //     |             |      RESTNotif1 |              |
3347 //     |             |<----------------|              |
3348 //     |             |                 |              |
3349 //     | RESTSubReq2                   |              |
3350 //     |------------------------------>|              |
3351 //     |             |                 |              |
3352 //     |                  RESTSubResp2 |              |
3353 //     |<------------------------------|              |
3354 //     |             |                 |              |
3355 //     |             |      RESTNotif2 |              |
3356 //     |<------------------------------|              |
3357 //     |             |                 |              |
3358 //     |             | RESTSubDelReq1  |              |
3359 //     |             |---------------->|              |
3360 //     |             |                 |              |
3361 //     |             | RESTSubDelResp1 |              |
3362 //     |             |<----------------|              |
3363 //     |             |                 |              |
3364 //     | RESTSubDelReq2                |              |
3365 //     |------------------------------>|              |
3366 //     |             |                 |              |
3367 //     |               RESTSubDelResp2 |              |
3368 //     |<------------------------------|              |
3369 //     |             |                 |              |
3370 //     |             |                 | SubDelReq2   |
3371 //     |             |                 |------------->|
3372 //     |             |                 |              |
3373 //     |             |                 |  SubDelResp2 |
3374 //     |             |                 |<-------------|
3375 //     |             |                 |              |
3376 //
3377 //-----------------------------------------------------------------------------
3378 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
3379         CaseBegin("TestRESTSubReqAndSubDelOkSameAction")
3380
3381         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3382                 Counter{cRestSubReqFromXapp, 2},
3383                 Counter{cSubReqToE2, 1},
3384                 Counter{cSubRespFromE2, 1},
3385                 Counter{cRestSubRespToXapp, 2},
3386                 Counter{cMergedSubscriptions, 1},
3387                 Counter{cUnmergedSubscriptions, 1},
3388                 Counter{cRestSubDelReqFromXapp, 2},
3389                 Counter{cSubDelReqToE2, 1},
3390                 Counter{cSubDelRespFromE2, 1},
3391                 Counter{cRestSubDelRespToXapp, 2},
3392         })
3393
3394         // Req1
3395         var params *teststube2ap.RESTSubsReqParams = nil
3396
3397         //Subs Create
3398         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3399         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
3400
3401         // Req2
3402         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3403         params.SetMeid("RAN_NAME_1")
3404
3405         xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
3406         xappConn2.WaitRESTNotificationForAnySubscriptionId(t)
3407         waiter := rtmgrHttp.AllocNextSleep(10, true)
3408         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3409         waiter.WaitResult(t)
3410         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
3411         e2SubsId2 := <-xappConn2.RESTNotification
3412         xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
3413
3414         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
3415
3416         // Del1
3417         xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3418
3419         // Del2
3420         deleteXapp2Subscription(t, &restSubId2)
3421
3422         //Wait that subs is cleaned
3423         waitSubsCleanup(t, e2SubsId2, 10)
3424
3425         mainCtrl.VerifyCounterValues(t)
3426 }
3427
3428 //-----------------------------------------------------------------------------
3429 // TestSubReqAndSubDelOkSameActionParallel
3430 //
3431 //   stub          stub                          stub
3432 // +-------+     +-------+     +---------+    +---------+
3433 // | xapp2 |     | xapp1 |     | submgr  |    | e2term  |
3434 // +-------+     +-------+     +---------+    +---------+
3435 //     |             |              |              |
3436 //     |             |              |              |
3437 //     |             |              |              |
3438 //     |             | SubReq1      |              |
3439 //     |             |------------->|              |
3440 //     |             |              |              |
3441 //     |             |              | SubReq1      |
3442 //     |             |              |------------->|
3443 //     |          SubReq2           |              |
3444 //     |--------------------------->|              |
3445 //     |             |              |    SubResp1  |
3446 //     |             |              |<-------------|
3447 //     |             |    SubResp1  |              |
3448 //     |             |<-------------|              |
3449 //     |             |              | SubReq2      |
3450 //     |             |              |------------->|
3451 //     |             |              |              |
3452 //     |             |              |    SubResp2  |
3453 //     |             |              |<-------------|
3454 //     |          SubResp2          |              |
3455 //     |<---------------------------|              |
3456 //     |             |              |              |
3457 //     |             | SubDelReq 1  |              |
3458 //     |             |------------->|              |
3459 //     |             |              |              |
3460 //     |             | SubDelResp 1 |              |
3461 //     |             |<-------------|              |
3462 //     |             |              |              |
3463 //     |         SubDelReq 2        |              |
3464 //     |--------------------------->|              |
3465 //     |             |              |              |
3466 //     |             |              | SubDelReq 2  |
3467 //     |             |              |------------->|
3468 //     |             |              |              |
3469 //     |             |              | SubDelReq 2  |
3470 //     |             |              |------------->|
3471 //     |             |              |              |
3472 //     |         SubDelResp 2       |              |
3473 //     |<---------------------------|              |
3474 //
3475 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
3476         CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel")
3477
3478         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3479                 Counter{cRestSubReqFromXapp, 2},
3480                 Counter{cSubReqToE2, 2},
3481                 Counter{cSubRespFromE2, 2},
3482                 Counter{cRestSubRespToXapp, 2},
3483                 Counter{cRestSubDelReqFromXapp, 2},
3484                 Counter{cSubDelReqToE2, 2},
3485                 Counter{cSubDelRespFromE2, 2},
3486                 Counter{cRestSubDelRespToXapp, 2},
3487         })
3488
3489         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3490         restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3491         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3492
3493         params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
3494         restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
3495
3496         xappConn1.ExpectRESTNotification(t, restSubId1)
3497         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3498         e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
3499
3500         xappConn2.ExpectRESTNotification(t, restSubId2)
3501         crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3502         e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3503         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
3504
3505         // Del1
3506         xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3507         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3508         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3509         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3510
3511         // Del2
3512         xappConn2.SendRESTSubsDelReq(t, &restSubId2)
3513         delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
3514         e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
3515
3516         waitSubsCleanup(t, e2SubsId2, 10)
3517
3518         mainCtrl.VerifyCounterValues(t)
3519 }
3520
3521 //-----------------------------------------------------------------------------
3522 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
3523 //
3524 //   stub          stub                             stub
3525 // +-------+     +-------+        +---------+    +---------+
3526 // | xapp2 |     | xapp1 |        | submgr  |    | e2term  |
3527 // +-------+     +-------+        +---------+    +---------+
3528 //     |             |                 |              |
3529 //     |             |                 |              |
3530 //     |             |                 |              |
3531 //     |             | RESTSubReq1     |              |
3532 //     |             |---------------->|              |
3533 //     |             |                 |              |
3534 //     |             |    RESTSubResp1 |              |
3535 //     |             |<----------------|              |
3536 //     |             |                 | SubReq1      |
3537 //     |             |                 |------------->|
3538 //     | RESTSubReq2                   |              |
3539 //     |------------------------------>|              |
3540 //     |             |                 |              |
3541 //     |               RESTSubDelResp2 |              |
3542 //     |<------------------------------|              |
3543 //     |             |                 | SubReq1      |
3544 //     |             |                 |------------->|
3545 //     |             |                 |              |
3546 //     |             |                 |              |
3547 //     |             |                 | SubDelReq    |
3548 //     |             |                 |------------->|
3549 //     |             |                 |              |
3550 //     |             |                 |   SubDelResp |
3551 //     |             |                 |<-------------|
3552 //     |             |      RESTNotif1 |              |
3553 //     |             |       unsuccess |              |
3554 //     |             |<----------------|              |
3555 //     |                    RESTNotif2 |              |
3556 //     |             |       unsuccess |              |
3557 //     |<------------------------------|              |
3558 //     |             |                 |              |
3559 //     |             | RESTSubDelReq1  |              |
3560 //     |             |---------------->|              |
3561 //     |             |                 |              |
3562 //     |             | RESTSubDelResp1 |              |
3563 //     |             |<----------------|              |
3564 //     |             |                 |              |
3565 //     | RESTSubDelReq2                |              |
3566 //     |------------------------------>|              |
3567 //     |             |                 |              |
3568 //     |               RESTSubDelResp2 |              |
3569 //     |<------------------------------|              |
3570 //
3571 //-----------------------------------------------------------------------------
3572 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
3573         CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
3574
3575         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3576                 Counter{cRestSubReqFromXapp, 2},
3577                 Counter{cSubReqToE2, 1},
3578                 Counter{cRestSubFailToXapp, 2},
3579                 Counter{cRestSubDelReqFromXapp, 2},
3580                 Counter{cSubDelReqToE2, 1},
3581                 Counter{cSubDelRespFromE2, 1},
3582                 Counter{cRestSubDelRespToXapp, 2},
3583         })
3584
3585         const subReqCount int = 1
3586
3587         // Req1
3588         params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3589         restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
3590         crereq1, _ := e2termConn1.RecvSubsReq(t)
3591
3592         // Req2
3593         subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
3594         params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
3595         params2.SetMeid("RAN_NAME_1")
3596         restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
3597         mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
3598
3599         //Req1 (retransmitted)
3600         e2termConn1.RecvSubsReq(t)
3601
3602         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3603
3604         xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3605         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3606
3607         e2SubsIdA := <-xappConn1.ListedRESTNotifications
3608         xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3609         e2SubsIdB := <-xappConn1.ListedRESTNotifications
3610         xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3611
3612         // Del1
3613         xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3614
3615         // Del2
3616         xappConn2.SendRESTSubsDelReq(t, &restSubId2)
3617
3618         mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
3619
3620         //Wait that subs is cleaned
3621         waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
3622
3623         mainCtrl.VerifyCounterValues(t)
3624 }
3625
3626 //-----------------------------------------------------------------------------
3627 // TestRESTSubReqAndSubDelNokSameActionParallel
3628 //
3629 //   stub          stub                             stub
3630 // +-------+     +-------+        +---------+    +---------+
3631 // | xapp2 |     | xapp1 |        | submgr  |    | e2term  |
3632 // +-------+     +-------+        +---------+    +---------+
3633 //     |             |                 |              |
3634 //     |             |                 |              |
3635 //     |             |                 |              |
3636 //     |             | RESTSubReq1     |              |
3637 //     |             |---------------->|              |
3638 //     |             |                 |              |
3639 //     |             |    RESTSubResp1 |              |
3640 //     |             |<----------------|              |
3641 //     |             |                 | SubReq1      |
3642 //     |             |                 |------------->|
3643 //     | RESTSubReq2                   |              |
3644 //     |------------------------------>|              |
3645 //     |             |                 |              |
3646 //     |               RESTSubDelResp2 |              |
3647 //     |<------------------------------|              |
3648 //     |             |                 |    SubFail1  |
3649 //     |             |                 |<-------------|
3650 //     |             |                 |              |
3651 //     |             |      RESTNotif1 |              |
3652 //     |             |       unsuccess |              |
3653 //     |             |<----------------|              |
3654 //     |                    RESTNotif2 |              |
3655 //     |             |       unsuccess |              |
3656 //     |<------------------------------|              |
3657 //     |             |                 | SubDelReq    |
3658 //     |             |                 |------------->|
3659 //     |             |                 |   SubDelResp |
3660 //     |             |                 |<-------------|
3661 //     |             |                 |              |
3662 //     |             | RESTSubDelReq1  |              |
3663 //     |             |---------------->|              |
3664 //     |             |                 |              |
3665 //     |             | RESTSubDelResp1 |              |
3666 //     |             |<----------------|              |
3667 //     |             |                 |              |
3668 //     | RESTSubDelReq2                |              |
3669 //     |------------------------------>|              |
3670 //     |             |                 |              |
3671 //     |               RESTSubDelResp2 |              |
3672 //     |<------------------------------|              |
3673 //
3674 //-----------------------------------------------------------------------------
3675 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
3676         CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
3677
3678         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3679                 Counter{cRestSubReqFromXapp, 2},
3680                 Counter{cSubReqToE2, 1},
3681                 Counter{cSubFailFromE2, 1},
3682                 Counter{cRestSubFailToXapp, 2},
3683                 Counter{cRestSubDelReqFromXapp, 2},
3684                 Counter{cSubDelReqToE2, 1},
3685                 Counter{cSubDelRespFromE2, 1},
3686                 Counter{cRestSubDelRespToXapp, 2},
3687         })
3688
3689         const subReqCount int = 1
3690
3691         // Req1
3692         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3693         restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3694         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3695
3696         // Req2
3697         subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
3698         params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
3699         params2.SetMeid("RAN_NAME_1")
3700         restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
3701         mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
3702
3703         // E2t: send SubsFail (first)
3704         fparams1 := &teststube2ap.E2StubSubsFailParams{}
3705         fparams1.Set(crereq1)
3706         e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3707
3708         // E2t: internal delete
3709         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3710         xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3711         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3712
3713         e2SubsIdA := <-xappConn1.ListedRESTNotifications
3714         xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3715         e2SubsIdB := <-xappConn1.ListedRESTNotifications
3716         xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3717
3718         // Del1
3719         xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3720
3721         // Del2
3722         xappConn2.SendRESTSubsDelReq(t, &restSubId2)
3723
3724         //Wait that subs is cleaned
3725         waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
3726         waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
3727
3728         mainCtrl.VerifyCounterValues(t)
3729 }
3730
3731 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
3732         CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
3733
3734         // Init counter check
3735         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3736                 Counter{cRestSubReqFromXapp, 1},
3737                 Counter{cSubReqToE2, 1},
3738                 Counter{cSubRespFromE2, 1},
3739                 Counter{cRestSubRespToXapp, 1},
3740                 Counter{cRestSubDelReqFromXapp, 1},
3741                 Counter{cSubDelReqToE2, 1},
3742                 Counter{cSubDelRespFromE2, 1},
3743                 Counter{cRestSubDelRespToXapp, 1},
3744         })
3745
3746         const subReqCount int = 1
3747
3748         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
3749         restSubId := xappConn1.SendRESTSubsReq(t, params)
3750         xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
3751
3752         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3753         xappConn1.ExpectRESTNotification(t, restSubId)
3754         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3755         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3756         xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
3757
3758         xappConn1.SendRESTSubsDelReq(t, &restSubId)
3759         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3760         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3761
3762         // Wait that subs is cleaned
3763         waitSubsCleanup(t, e2SubsId, 10)
3764         mainCtrl.VerifyCounterValues(t)
3765 }
3766
3767 //-----------------------------------------------------------------------------
3768 // TestRESTSubReqPolicyChangeAndSubDelOk
3769 //
3770 //   stub                             stub
3771 // +-------+        +---------+    +---------+
3772 // | xapp  |        | submgr  |    | e2term  |
3773 // +-------+        +---------+    +---------+
3774 //     |                 |              |
3775 //     | RESTSubReq      |              |
3776 //     |---------------->|              |
3777 //     |                 |              |
3778 //     |     RESTSubResp |              |
3779 //     |<----------------|              |
3780 //     |                 | SubReq       |
3781 //     |                 |------------->|
3782 //     |                 |              |
3783 //     |                 |      SubResp |
3784 //     |                 |<-------------|
3785 //     |                 |              |
3786 //     |       RESTNotif |              |
3787 //     |<----------------|              |
3788 //     |                 |              |
3789 //     | RESTSubReq      |              |
3790 //     |---------------->|              |
3791 //     |                 |              |
3792 //     |     RESTSubResp |              |
3793 //     |<----------------|              |
3794 //     |                 | SubReq       |
3795 //     |                 |------------->|
3796 //     |                 |              |
3797 //     |                 |      SubResp |
3798 //     |                 |<-------------|
3799 //     |                 |              |
3800 //     |       RESTNotif |              |
3801 //     |<----------------|              |
3802 //     |                 |              |
3803 //     | RESTSubDelReq   |              |
3804 //     |---------------->|              |
3805 //     |                 |              |
3806 //     |                 | SubDelReq    |
3807 //     |                 |------------->|
3808 //     |                 |              |
3809 //     |                 |   SubDelResp |
3810 //     |                 |<-------------|
3811 //     |                 |              |
3812 //     |  RESTSubDelResp |              |
3813 //     |<----------------|              |
3814 //
3815 //-----------------------------------------------------------------------------
3816 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
3817         CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
3818
3819         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3820                 Counter{cRestSubReqFromXapp, 2},
3821                 Counter{cSubReqToE2, 2},
3822                 Counter{cSubRespFromE2, 2},
3823                 Counter{cRestSubRespToXapp, 2},
3824                 Counter{cRestSubDelReqFromXapp, 1},
3825                 Counter{cSubDelReqToE2, 1},
3826                 Counter{cSubDelRespFromE2, 1},
3827                 Counter{cRestSubDelRespToXapp, 1},
3828         })
3829
3830         const subReqCount int = 1
3831
3832         // Req
3833         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
3834         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3835
3836         // Policy change
3837         instanceId := int64(e2SubsId)
3838         // GetRESTSubsReqPolicyParams sets some coutners on tc side.
3839         params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
3840         params.SubsReqParams.SubscriptionDetails[0].InstanceID = &instanceId
3841         params.SetTimeToWait("w200ms")
3842         restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
3843
3844         // Del
3845         xappConn1.SendRESTSubsDelReq(t, &restSubId)
3846
3847         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3848         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3849
3850         // Wait that subs is cleaned
3851         waitSubsCleanup(t, e2SubsId, 10)
3852         mainCtrl.VerifyCounterValues(t)
3853 }
3854
3855 //-----------------------------------------------------------------------------
3856 // TestRESTSubReqAndSubDelOkTwoE2termParallel
3857 //
3858 //   stub                             stub           stub
3859 // +-------+        +---------+    +---------+    +---------+
3860 // | xapp  |        | submgr  |    | e2term1 |    | e2term2 |
3861 // +-------+        +---------+    +---------+    +---------+
3862 //     |                 |              |              |
3863 //     |                 |              |              |
3864 //     |                 |              |              |
3865 //     | RESTSubReq1     |              |              |
3866 //     |---------------->|              |              |
3867 //     |                 |              |              |
3868 //     |    RESTSubResp1 |              |              |
3869 //     |<----------------|              |              |
3870 //     |                 | SubReq1      |              |
3871 //     |                 |------------->|              |
3872 //     |                 |              |              |
3873 //     | RESTSubReq2     |              |              |
3874 //     |---------------->|              |              |
3875 //     |                 |              |              |
3876 //     |    RESTSubResp2 |              |              |
3877 //     |<----------------|              |              |
3878 //     |                 | SubReq2      |              |
3879 //     |                 |---------------------------->|
3880 //     |                 |              |              |
3881 //     |                 |    SubResp1  |              |
3882 //     |                 |<-------------|              |
3883 //     |      RESTNotif1 |              |              |
3884 //     |<----------------|              |              |
3885 //     |                 |    SubResp2  |              |
3886 //     |                 |<----------------------------|
3887 //     |      RESTNotif2 |              |              |
3888 //     |<----------------|              |              |
3889 //     |                 |              |              |
3890 //     |           [SUBS 1 DELETE]      |              |
3891 //     |                 |              |              |
3892 //     |           [SUBS 2 DELETE]      |              |
3893 //     |                 |              |              |
3894 //
3895 //-----------------------------------------------------------------------------
3896 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
3897         CaseBegin("TestRESTSubReqAndSubDelOkTwoE2termParallel")
3898
3899         // Init counter check
3900         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3901                 Counter{cRestSubReqFromXapp, 2},
3902                 Counter{cSubReqToE2, 2},
3903                 Counter{cSubRespFromE2, 2},
3904                 Counter{cRestSubRespToXapp, 2},
3905                 Counter{cRestSubDelReqFromXapp, 2},
3906                 Counter{cSubDelReqToE2, 2},
3907                 Counter{cSubDelRespFromE2, 2},
3908                 Counter{cRestSubDelRespToXapp, 2},
3909         })
3910
3911         const subReqCount int = 1
3912
3913         // Req1
3914         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3915         restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3916         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3917
3918         // Req2
3919         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3920         params.SetMeid("RAN_NAME_11")
3921         // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
3922         // would not work as notification would not be received
3923         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3924         crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
3925
3926         // Resp1
3927         xappConn1.ExpectRESTNotification(t, restSubId1)
3928         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3929         e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
3930         xapp.Logger.Info("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
3931
3932         // Resp2
3933         xappConn2.ExpectRESTNotification(t, restSubId2)
3934         e2termConn2.SendSubsResp(t, crereq2, cremsg2)
3935         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
3936         xapp.Logger.Info("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
3937
3938         // Delete1
3939         xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3940         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3941         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3942
3943         // Wait that subs is cleaned
3944         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3945
3946         // Delete2
3947         xappConn1.SendRESTSubsDelReq(t, &restSubId2)
3948         delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
3949         e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
3950
3951         // Wait that subs is cleaned
3952         waitSubsCleanup(t, e2SubsId2, 10)
3953
3954         mainCtrl.VerifyCounterValues(t)
3955 }
3956
3957 //-----------------------------------------------------------------------------
3958 // TestRESTSubReqAsn1EncodeFail
3959 //
3960 // In this case submgr send RICSubscriptionDeleteRequest after encode failure which should not happen!
3961 //   stub                             stub
3962 // +-------+        +---------+    +---------+
3963 // | xapp  |        | submgr  |    | e2term  |
3964 // +-------+        +---------+    +---------+
3965 //     |                 |              |
3966 //     | RESTSubReq      |              |
3967 //     |---------------->|              |
3968 //     |                 |              |
3969 //     |     RESTSubResp |              |
3970 //     |<----------------|              |
3971 //     | RESTSubDelReq   |              |
3972 //     |---------------->|              |
3973 //     |  RESTSubDelResp |              |
3974 //     |     unsuccess   |              |
3975 //     |<----------------|              |
3976 //     |                 |              |
3977 //
3978 //-----------------------------------------------------------------------------
3979 func TestRESTSubReqAsn1EncodeFail(t *testing.T) {
3980         CaseBegin("TestRESTSubReqAsn1EncodeFail")
3981
3982         xapp.Logger.Info("Xapp-frame, v0.8.1 sufficient REST API validation")
3983
3984 }
3985
3986 //-----------------------------------------------------------------------------
3987 // TestRESTSubReqInsertAndSubDelOk
3988 //
3989 //   stub                             stub
3990 // +-------+        +---------+    +---------+
3991 // | xapp  |        | submgr  |    | e2term  |
3992 // +-------+        +---------+    +---------+
3993 //     |                 |              |
3994 //     | RestSubReq      |              |
3995 //     |---------------->|              |
3996 //     |                 |              |
3997 //     |     RESTSubResp |              |
3998 //     |<----------------|              |
3999 //     |                 |              |
4000 //     |                 | SubReq       |
4001 //     |                 |------------->|
4002 //     |                 |              |
4003 //     |                 |      SubResp |
4004 //     |                 |<-------------|
4005 //     | RESTNotif       |              |
4006 //     |<----------------|              |
4007 //     |       ...       |     ...      |
4008 //     |                 |              |
4009 //     | RESTSubDelReq   |              |
4010 //     |---------------->|              |
4011 //     |                 |              |
4012 //     |                 | SubDelReq    |
4013 //     |                 |------------->|
4014 //     |                 |              |
4015 //     |                 |   SubDelResp |
4016 //     |                 |<-------------|
4017 //     |                 |              |
4018 //     |   RESTSubDelResp|              |
4019 //     |<----------------|              |
4020 //
4021 //-----------------------------------------------------------------------------
4022 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
4023         CaseBegin("TestRESTInsertSubReqAndSubDelOk")
4024
4025         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4026                 Counter{cRestSubReqFromXapp, 1},
4027                 Counter{cSubReqToE2, 1},
4028                 Counter{cSubRespFromE2, 1},
4029                 Counter{cRestSubRespToXapp, 1},
4030                 Counter{cRestSubDelReqFromXapp, 1},
4031                 Counter{cSubDelReqToE2, 1},
4032                 Counter{cSubDelRespFromE2, 1},
4033                 Counter{cRestSubDelRespToXapp, 1},
4034         })
4035
4036         const subReqCount int = 1
4037
4038         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4039         params.SetSubActionTypes("insert")
4040
4041         // Req
4042         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4043
4044         // Del
4045         xappConn1.SendRESTSubsDelReq(t, &restSubId)
4046
4047         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4048         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4049
4050         // Wait that subs is cleaned
4051         waitSubsCleanup(t, e2SubsId, 10)
4052         mainCtrl.VerifyCounterValues(t)
4053 }
4054
4055 //-----------------------------------------------------------------------------
4056 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
4057 //
4058 //   stub                          stub
4059 // +-------+     +---------+    +---------+
4060 // | xapp  |     | submgr  |    | e2term  |
4061 // +-------+     +---------+    +---------+
4062 //     |              |              |
4063 //     | RESTSubReq   |              |
4064 //     |------------->|              |
4065 //     |              |              |
4066 //     |              | SubReq       |
4067 //     |              |------------->|
4068 //     |              |              |
4069 //     |              |      SubResp |
4070 //     |                        <----|
4071 //     |                             |
4072 //     |        Submgr restart       |
4073 //     |                             |
4074 //     |              |              |
4075 //     |              | SubDelReq    |
4076 //     |              |------------->|
4077 //     |              |              |
4078 //     |              |   SubDelResp |
4079 //     |              |<-------------|
4080 //     |              |              |
4081 //
4082 //-----------------------------------------------------------------------------
4083 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
4084         CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle")
4085
4086         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4087                 Counter{cRestSubReqFromXapp, 1},
4088                 Counter{cSubReqToE2, 1},
4089                 Counter{cSubDelReqFromXapp, 1},
4090                 Counter{cSubDelReqToE2, 1},
4091                 Counter{cSubDelRespFromE2, 1},
4092         })
4093
4094         const subReqCount int = 1
4095
4096         // Remove possible existing subscription
4097         mainCtrl.removeExistingSubscriptions(t)
4098
4099         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4100
4101         //Req
4102         mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
4103         restSubId := xappConn1.SendRESTSubsReq(t, params)
4104         xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
4105
4106         e2termConn1.RecvSubsReq(t)
4107
4108         mainCtrl.SetResetTestFlag(t, false)
4109
4110         mainCtrl.SimulateRestart(t)
4111         xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4112
4113         //Del
4114         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4115         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4116
4117         xappConn1.TestMsgChanEmpty(t)
4118         xappConn2.TestMsgChanEmpty(t)
4119         e2termConn1.TestMsgChanEmpty(t)
4120         mainCtrl.wait_registry_empty(t, 10)
4121
4122         mainCtrl.VerifyCounterValues(t)
4123 }
4124
4125 //-----------------------------------------------------------------------------
4126 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
4127 //
4128 //   stub                             stub
4129 // +-------+        +---------+    +---------+
4130 // | xapp  |        | submgr  |    | e2term  |
4131 // +-------+        +---------+    +---------+
4132 //     |                 |              |
4133 //     | RESTSubReq      |              |
4134 //     |---------------->|              |
4135 //     |                 |              |
4136 //     |     RESTSubResp |              |
4137 //     |<----------------|              |
4138 //     |                 | SubReq       |
4139 //     |                 |------------->|
4140 //     |                 |              |
4141 //     |                 |      SubResp |
4142 //     |                 |<-------------|
4143 //     |                 |              |
4144 //     |       RESTNotif |              |
4145 //     |<----------------|              |
4146 //     |                 |              |
4147 //     |                                |
4148 //     |           Submgr restart       |
4149 //     |                 |              |
4150 //     | RESTSubDelReq   |              |
4151 //     |---------------->|              |
4152 //     |                 |              |
4153 //     |                 | SubDelReq    |
4154 //     |                 |------------->|
4155 //     |                 |              |
4156 //     |                 |   SubDelResp |
4157 //     |                 |<-------------|
4158 //     |                 |              |
4159 //     |  RESTSubDelResp |              |
4160 //     |<----------------|              |
4161 //
4162 //-----------------------------------------------------------------------------
4163 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
4164         CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle")
4165
4166         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4167                 Counter{cRestSubReqFromXapp, 1},
4168                 Counter{cSubReqToE2, 1},
4169                 Counter{cSubRespFromE2, 1},
4170                 Counter{cRestSubRespToXapp, 1},
4171                 Counter{cRestSubDelReqFromXapp, 1},
4172                 Counter{cSubDelReqToE2, 1},
4173                 Counter{cRestSubDelRespToXapp, 1},
4174         })
4175
4176         // Remove possible existing subscription
4177         mainCtrl.removeExistingSubscriptions(t)
4178
4179         var params *teststube2ap.RESTSubsReqParams = nil
4180
4181         // Create subscription
4182         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4183         xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
4184
4185         // Check subscription
4186         queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4187
4188         // When SDL support for the REST Interface is added
4189         // the submgr restart statement below should be removed
4190         // from the comment.
4191
4192         //      mainCtrl.SimulateRestart(t)
4193         //      xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4194
4195         // Check subscription
4196         queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4197
4198         // Delete subscription
4199         deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
4200
4201         //Wait that subs is cleaned
4202         waitSubsCleanup(t, e2SubsId, 10)
4203
4204         mainCtrl.VerifyCounterValues(t)
4205 }
4206
4207 //-----------------------------------------------------------------------------
4208 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
4209 //
4210 //   stub                             stub
4211 // +-------+     +-------+        +---------+    +---------+
4212 // | xapp2 |     | xapp1 |        | submgr  |    | e2term  |
4213 // +-------+     +-------+        +---------+    +---------+
4214 //     |             |                 |              |
4215 //     |             | RESTSubReq1     |              |
4216 //     |             |---------------->|              |
4217 //     |             |                 |              |
4218 //     |             |    RESTSubResp1 |              |
4219 //     |             |<----------------|              |
4220 //     |             |                 |              |
4221 //     |             |                 | SubReq1      |
4222 //     |             |                 |------------->|
4223 //     |             |                 |    SubResp1  |
4224 //     |             |                 |<-------------|
4225 //     |             |      RESTNotif1 |              |
4226 //     |             |<----------------|              |
4227 //     |             |                 |              |
4228 //     | RESTSubReq2                   |              |
4229 //     |------------------------------>|              |
4230 //     |             |                 |              |
4231 //     |                  RESTSubResp2 |              |
4232 //     |<------------------------------|              |
4233 //     |             |                 |              |
4234 //     |             |      RESTNotif2 |              |
4235 //     |<------------------------------|              |
4236 //     |             |                 |              |
4237 //     |             |           Submgr restart       |
4238 //     |             |                 |              |
4239 //     |             | RESTSubDelReq1  |              |
4240 //     |             |---------------->|              |
4241 //     |             |                 |              |
4242 //     |             | RESTSubDelResp1 |              |
4243 //     |             |<----------------|              |
4244 //     |             |                 |              |
4245 //     |             |           Submgr restart       |
4246 //     |             |                 |              |
4247 //     | RESTSubDelReq2                |              |
4248 //     |------------------------------>|              |
4249 //     |             |                 |              |
4250 //     |               RESTSubDelResp2 |              |
4251 //     |<------------------------------|              |
4252 //     |             |                 |              |
4253 //     |             |                 | SubDelReq2   |
4254 //     |             |                 |------------->|
4255 //     |             |                 |              |
4256 //     |             |                 |  SubDelResp2 |
4257 //     |             |                 |<-------------|
4258 //     |             |                 |              |
4259 //
4260 //-----------------------------------------------------------------------------
4261 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
4262         CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
4263
4264         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4265                 Counter{cRestSubReqFromXapp, 2},
4266                 Counter{cSubReqToE2, 1},
4267                 Counter{cSubRespFromE2, 1},
4268                 Counter{cRestSubRespToXapp, 2},
4269                 Counter{cMergedSubscriptions, 1},
4270                 Counter{cUnmergedSubscriptions, 1},
4271                 Counter{cRestSubDelReqFromXapp, 2},
4272                 Counter{cSubDelReqToE2, 1},
4273                 Counter{cSubDelRespFromE2, 1},
4274                 Counter{cRestSubDelRespToXapp, 2},
4275         })
4276
4277         // Remove possible existing subscription
4278         mainCtrl.removeExistingSubscriptions(t)
4279
4280         var params *teststube2ap.RESTSubsReqParams = nil
4281
4282         // Create subscription 1
4283         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4284         xapp.Logger.Info("Send REST subscriber request for subscriber 1 : %v", restSubId1)
4285
4286         // Create subscription 2 with same action
4287         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4288         params.SetMeid("RAN_NAME_1")
4289         xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4290         xappConn2.WaitRESTNotificationForAnySubscriptionId(t)
4291         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4292         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4293         e2SubsId2 := <-xappConn2.RESTNotification
4294         xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
4295
4296         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
4297
4298         // When SDL support for the REST Interface is added
4299         // the submgr restart statement below should be removed
4300         // from the comment.
4301
4302         //      mainCtrl.SimulateRestart(t)
4303         //      xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4304
4305         // Delete subscription 1, and wait until it has removed the first endpoint
4306         subepcnt := mainCtrl.get_subs_entrypoint_cnt(t, e2SubsId1)
4307         xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4308         mainCtrl.wait_subs_entrypoint_cnt_change(t, e2SubsId1, subepcnt, 10)
4309
4310         // When SDL support for the REST Interface is added
4311         // the submgr restart statement below should be removed
4312         // from the comment.
4313
4314         //      mainCtrl.SimulateRestart(t)
4315         //      xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4316         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
4317
4318         // Delete subscription 2
4319         deleteXapp2Subscription(t, &restSubId2)
4320
4321         //Wait that subs is cleaned
4322         waitSubsCleanup(t, e2SubsId2, 10)
4323
4324         mainCtrl.VerifyCounterValues(t)
4325 }
4326
4327 //-----------------------------------------------------------------------------
4328 // TestRESTReportSubReqAndSubDelOk
4329 //
4330 //   stub                             stub
4331 // +-------+        +---------+    +---------+
4332 // | xapp  |        | submgr  |    | e2term  |
4333 // +-------+        +---------+    +---------+
4334 //     |                 |              |
4335 //     | RestSubReq      |              |
4336 //     |---------------->|              |
4337 //     |                 |              |
4338 //     |     RESTSubResp |              |
4339 //     |<----------------|              |
4340 //     |                 |              |
4341 //     |                 | SubReq       |
4342 //     |                 |------------->|
4343 //     |                 |              |
4344 //     |                 |      SubResp |
4345 //     |                 |<-------------|
4346 //     | RESTNotif       |              |
4347 //     |<----------------|              |
4348 //     |                 | SubReq       |
4349 //     |                 |------------->|
4350 //     |                 |              |
4351 //     |                 |      SubResp |
4352 //     |                 |<-------------|
4353 //     | RESTNotif       |              |
4354 //     |<----------------|              |
4355 //     |       ...       |     ...      |
4356 //     |                 |              |
4357 //     |                 |              |
4358 //     | RESTSubDelReq   |              |
4359 //     |---------------->|              |
4360 //     |                 |              |
4361 //     |                 | SubDelReq    |
4362 //     |                 |------------->|
4363 //     |                 |              |
4364 //     |                 |   SubDelResp |
4365 //     |                 |<-------------|
4366 //     |                 |              |
4367 //     |   RESTSubDelResp|              |
4368 //     |<----------------|              |
4369 //
4370 //-----------------------------------------------------------------------------
4371 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
4372         CaseBegin("TestRESTReportSubReqAndSubDelOk")
4373         subReqCount := 1
4374         testIndex := 1
4375         RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
4376 }
4377
4378 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
4379         xapp.Logger.Info("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
4380
4381         // Req
4382         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4383         restSubId := xappConn1.SendRESTSubsReq(t, params)
4384
4385         var e2SubsId []uint32
4386         for i := 0; i < subReqCount; i++ {
4387                 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4388                 xappConn1.ExpectRESTNotification(t, restSubId)
4389
4390                 e2termConn1.SendSubsResp(t, crereq, cremsg)
4391                 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
4392                 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
4393                 e2SubsId = append(e2SubsId, instanceId)
4394                 resp, _ := xapp.Subscription.QuerySubscriptions()
4395                 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
4396                 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
4397                 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
4398
4399         }
4400
4401         // Del
4402         xappConn1.SendRESTSubsDelReq(t, &restSubId)
4403
4404         for i := 0; i < subReqCount; i++ {
4405                 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4406                 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4407         }
4408
4409         // Wait that subs is cleaned
4410         for i := 0; i < subReqCount; i++ {
4411                 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
4412         }
4413
4414         xappConn1.TestMsgChanEmpty(t)
4415         e2termConn1.TestMsgChanEmpty(t)
4416         mainCtrl.wait_registry_empty(t, 10)
4417 }
4418
4419 /*
4420 func TestRESTPolicySubReqAndSubDelOk(t *testing.T) {
4421         CaseBegin("TestRESTPolicySubReqAndSubDelOk")
4422
4423         subReqCount := 2
4424         testIndex := 1
4425         RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
4426
4427         subReqCount = 19
4428         testIndex = 2
4429         RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
4430 }
4431 */
4432 func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
4433         xapp.Logger.Info("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
4434
4435         // Req
4436         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4437         restSubId := xappConn1.SendRESTSubsReq(t, params)
4438         //params := xappConn1.GetRESTSubsReqPolicyParams1(subReqCount)
4439         //restSubId := xappConn1.SendRESTPolicySubsReq(t, params)
4440
4441         var e2SubsId []uint32
4442         for i := 0; i < subReqCount; i++ {
4443                 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4444                 xappConn1.ExpectRESTNotification(t, restSubId)
4445                 e2termConn1.SendSubsResp(t, crereq, cremsg)
4446                 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
4447                 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
4448                 e2SubsId = append(e2SubsId, instanceId)
4449         }
4450
4451         // Del
4452         xappConn1.SendRESTSubsDelReq(t, &restSubId)
4453
4454         for i := 0; i < subReqCount; i++ {
4455                 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4456                 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4457         }
4458
4459         // Wait that subs is cleaned
4460         for i := 0; i < subReqCount; i++ {
4461                 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
4462         }
4463         xappConn1.TestMsgChanEmpty(t)
4464         e2termConn1.TestMsgChanEmpty(t)
4465         mainCtrl.wait_registry_empty(t, 10)
4466 }
4467
4468 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
4469
4470         subReqCount := 2
4471
4472         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4473                 Counter{cRestSubReqFromXapp, 1},
4474                 Counter{cSubReqToE2, 2},
4475                 Counter{cSubRespFromE2, 2},
4476                 Counter{cRestSubRespToXapp, 2},
4477                 Counter{cRestSubDelReqFromXapp, 1},
4478                 Counter{cSubDelReqToE2, 2},
4479                 Counter{cSubDelRespFromE2, 2},
4480                 Counter{cRestSubDelRespToXapp, 1},
4481         })
4482
4483         // Req
4484         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4485         restSubId := xappConn1.SendRESTSubsReq(t, params)
4486         e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4487
4488         assert.Equal(t, len(e2SubsIds), 2)
4489
4490         // Del
4491         xappConn1.SendRESTSubsDelReq(t, &restSubId)
4492         sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4493
4494         xappConn1.TestMsgChanEmpty(t)
4495         e2termConn1.TestMsgChanEmpty(t)
4496         mainCtrl.wait_registry_empty(t, 10)
4497
4498         mainCtrl.VerifyCounterValues(t)
4499 }
4500 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
4501
4502         subReqCount := 19
4503
4504         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4505                 Counter{cRestSubReqFromXapp, 1},
4506                 Counter{cSubReqToE2, 19},
4507                 Counter{cSubRespFromE2, 19},
4508                 Counter{cRestSubRespToXapp, 19},
4509                 Counter{cRestSubDelReqFromXapp, 1},
4510                 Counter{cSubDelReqToE2, 19},
4511                 Counter{cSubDelRespFromE2, 19},
4512                 Counter{cRestSubDelRespToXapp, 1},
4513         })
4514
4515         // Req
4516         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4517         restSubId := xappConn1.SendRESTSubsReq(t, params)
4518         e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4519
4520         assert.Equal(t, len(e2SubsIds), 19)
4521
4522         xappConn1.SendRESTSubsDelReq(t, &restSubId)
4523         sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4524
4525         xappConn1.TestMsgChanEmpty(t)
4526         e2termConn1.TestMsgChanEmpty(t)
4527         mainCtrl.wait_registry_empty(t, 10)
4528
4529         mainCtrl.VerifyCounterValues(t)
4530 }
4531 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
4532
4533         subReqCount := 2
4534
4535         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4536                 Counter{cRestSubReqFromXapp, 1},
4537                 Counter{cSubReqToE2, uint64(subReqCount)},
4538                 Counter{cSubRespFromE2, uint64(subReqCount)},
4539                 Counter{cRestSubRespToXapp, uint64(subReqCount)},
4540                 Counter{cRestSubDelReqFromXapp, 1},
4541                 Counter{cSubDelReqToE2, uint64(subReqCount)},
4542                 Counter{cSubDelRespFromE2, uint64(subReqCount)},
4543                 Counter{cRestSubDelRespToXapp, 1},
4544         })
4545
4546         // Req
4547         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4548         restSubId := xappConn1.SendRESTSubsReq(t, params)
4549         e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4550
4551         assert.Equal(t, len(e2SubsIds), subReqCount)
4552
4553         // Del
4554         xappConn1.SendRESTSubsDelReq(t, &restSubId)
4555         sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4556
4557         xappConn1.TestMsgChanEmpty(t)
4558         e2termConn1.TestMsgChanEmpty(t)
4559         mainCtrl.wait_registry_empty(t, 10)
4560
4561         mainCtrl.VerifyCounterValues(t)
4562 }
4563
4564 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
4565
4566         subReqCount := 2
4567
4568         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4569                 Counter{cRestSubReqFromXapp, 1},
4570                 Counter{cSubReqToE2, uint64(subReqCount)},
4571                 Counter{cSubRespFromE2, uint64(subReqCount)},
4572                 Counter{cRestSubRespToXapp, uint64(subReqCount)},
4573                 Counter{cRestSubDelReqFromXapp, 1},
4574                 Counter{cSubDelReqToE2, uint64(subReqCount)},
4575                 Counter{cSubDelRespFromE2, uint64(subReqCount)},
4576                 Counter{cRestSubDelRespToXapp, 1},
4577         })
4578
4579         // Req
4580         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4581         restSubId := xappConn1.SendRESTSubsReq(t, params)
4582         e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4583
4584         assert.Equal(t, len(e2SubsIds), subReqCount)
4585
4586         // Del
4587         xappConn1.SendRESTSubsDelReq(t, &restSubId)
4588         sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4589
4590         xappConn1.TestMsgChanEmpty(t)
4591         e2termConn1.TestMsgChanEmpty(t)
4592         mainCtrl.wait_registry_empty(t, 10)
4593
4594         mainCtrl.VerifyCounterValues(t)
4595 }
4596
4597 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
4598
4599         subReqCount := 19
4600
4601         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4602                 Counter{cRestSubReqFromXapp, 1},
4603                 Counter{cSubReqToE2, uint64(subReqCount)},
4604                 Counter{cSubRespFromE2, uint64(subReqCount)},
4605                 Counter{cRestSubRespToXapp, uint64(subReqCount)},
4606                 Counter{cRestSubDelReqFromXapp, 1},
4607                 Counter{cSubDelReqToE2, uint64(subReqCount)},
4608                 Counter{cSubDelRespFromE2, uint64(subReqCount)},
4609                 Counter{cRestSubDelRespToXapp, 1},
4610         })
4611
4612         // Req
4613         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4614         restSubId := xappConn1.SendRESTSubsReq(t, params)
4615         e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
4616
4617         assert.Equal(t, len(e2SubsIds), subReqCount)
4618
4619         // Del
4620         xappConn1.SendRESTSubsDelReq(t, &restSubId)
4621         sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4622
4623         xappConn1.TestMsgChanEmpty(t)
4624         e2termConn1.TestMsgChanEmpty(t)
4625         mainCtrl.wait_registry_empty(t, 10)
4626
4627         mainCtrl.VerifyCounterValues(t)
4628 }
4629
4630 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
4631         CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
4632
4633         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4634                 Counter{cRestSubReqFromXapp, 2},
4635                 Counter{cSubReqToE2, 2},
4636                 Counter{cSubRespFromE2, 2},
4637                 Counter{cRestSubRespToXapp, 2},
4638                 Counter{cRestSubDelReqFromXapp, 2},
4639                 Counter{cSubDelReqToE2, 2},
4640                 Counter{cSubDelRespFromE2, 2},
4641                 Counter{cRestSubDelRespToXapp, 2},
4642         })
4643
4644         // Req1
4645         var params *teststube2ap.RESTSubsReqParams = nil
4646
4647         //Subs Create
4648         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4649         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4650
4651         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4652
4653         // Req2
4654         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4655         params.SetMeid("RAN_NAME_1")
4656         eventTriggerDefinition := "1234"
4657         params.SetSubEventTriggerDefinition(eventTriggerDefinition)
4658
4659         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4660         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4661         crereq, cremsg := e2termConn1.RecvSubsReq(t)
4662         xappConn2.ExpectRESTNotification(t, restSubId2)
4663         e2termConn1.SendSubsResp(t, crereq, cremsg)
4664         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4665
4666         deleteXapp1Subscription(t, &restSubId1)
4667         deleteXapp2Subscription(t, &restSubId2)
4668
4669         waitSubsCleanup(t, e2SubsId1, 10)
4670         waitSubsCleanup(t, e2SubsId2, 10)
4671
4672         mainCtrl.VerifyCounterValues(t)
4673
4674 }
4675
4676 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
4677         CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
4678
4679         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4680                 Counter{cRestSubReqFromXapp, 2},
4681                 Counter{cSubReqToE2, 2},
4682                 Counter{cSubRespFromE2, 2},
4683                 Counter{cRestSubRespToXapp, 2},
4684                 Counter{cRestSubDelReqFromXapp, 2},
4685                 Counter{cSubDelReqToE2, 2},
4686                 Counter{cSubDelRespFromE2, 2},
4687                 Counter{cRestSubDelRespToXapp, 2},
4688         })
4689
4690         // Req1
4691         var params *teststube2ap.RESTSubsReqParams = nil
4692
4693         //Subs Create
4694         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4695         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4696
4697         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4698
4699         // Req2
4700         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4701         params.SetMeid("RAN_NAME_1")
4702
4703         actionId := int64(1)
4704         actionType := "report"
4705         actionDefinition := "56781"
4706         subsequestActionType := "continue"
4707         timeToWait := "w10ms"
4708         params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
4709
4710         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4711         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4712         crereq, cremsg := e2termConn1.RecvSubsReq(t)
4713         xappConn2.ExpectRESTNotification(t, restSubId2)
4714         e2termConn1.SendSubsResp(t, crereq, cremsg)
4715         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4716
4717         deleteXapp1Subscription(t, &restSubId1)
4718         deleteXapp2Subscription(t, &restSubId2)
4719
4720         waitSubsCleanup(t, e2SubsId1, 10)
4721         waitSubsCleanup(t, e2SubsId2, 10)
4722
4723         mainCtrl.VerifyCounterValues(t)
4724
4725 }
4726
4727 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
4728         CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
4729
4730         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4731                 Counter{cRestSubReqFromXapp, 2},
4732                 Counter{cSubReqToE2, 2},
4733                 Counter{cSubRespFromE2, 2},
4734                 Counter{cRestSubRespToXapp, 2},
4735                 Counter{cRestSubDelReqFromXapp, 2},
4736                 Counter{cSubDelReqToE2, 2},
4737                 Counter{cSubDelRespFromE2, 2},
4738                 Counter{cRestSubDelRespToXapp, 2},
4739         })
4740
4741         // Req1
4742         var params *teststube2ap.RESTSubsReqParams = nil
4743
4744         //Subs Create
4745         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4746         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4747
4748         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4749
4750         // Req2
4751         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4752         params.SetMeid("RAN_NAME_1")
4753         params.SetSubActionIDs(int64(2))
4754
4755         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4756         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4757         crereq, cremsg := e2termConn1.RecvSubsReq(t)
4758         xappConn2.ExpectRESTNotification(t, restSubId2)
4759         e2termConn1.SendSubsResp(t, crereq, cremsg)
4760         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4761
4762         deleteXapp1Subscription(t, &restSubId1)
4763         deleteXapp2Subscription(t, &restSubId2)
4764
4765         waitSubsCleanup(t, e2SubsId1, 10)
4766         waitSubsCleanup(t, e2SubsId2, 10)
4767
4768         mainCtrl.VerifyCounterValues(t)
4769
4770 }
4771
4772 func TestRESTSubReqDiffActionType(t *testing.T) {
4773         CaseBegin("TestRESTSubReqDiffActionType")
4774
4775         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4776                 Counter{cRestSubReqFromXapp, 2},
4777                 Counter{cSubReqToE2, 2},
4778                 Counter{cSubRespFromE2, 2},
4779                 Counter{cRestSubRespToXapp, 2},
4780                 Counter{cRestSubDelReqFromXapp, 2},
4781                 Counter{cSubDelReqToE2, 2},
4782                 Counter{cSubDelRespFromE2, 2},
4783                 Counter{cRestSubDelRespToXapp, 2},
4784         })
4785
4786         // Req1
4787         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4788
4789         //Subs Create
4790         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4791         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4792
4793         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4794
4795         // Req2
4796         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4797         params.SetMeid("RAN_NAME_1")
4798
4799         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4800         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4801         crereq, cremsg := e2termConn1.RecvSubsReq(t)
4802         xappConn2.ExpectRESTNotification(t, restSubId2)
4803         e2termConn1.SendSubsResp(t, crereq, cremsg)
4804         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4805
4806         deleteXapp1Subscription(t, &restSubId1)
4807         deleteXapp2Subscription(t, &restSubId2)
4808
4809         waitSubsCleanup(t, e2SubsId1, 10)
4810         waitSubsCleanup(t, e2SubsId2, 10)
4811
4812         mainCtrl.VerifyCounterValues(t)
4813
4814 }
4815
4816 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
4817         CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
4818
4819         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4820                 Counter{cRestSubReqFromXapp, 2},
4821                 Counter{cSubReqToE2, 2},
4822                 Counter{cSubRespFromE2, 2},
4823                 Counter{cRestSubRespToXapp, 2},
4824                 Counter{cRestSubDelReqFromXapp, 2},
4825                 Counter{cSubDelReqToE2, 2},
4826                 Counter{cSubDelRespFromE2, 2},
4827                 Counter{cRestSubDelRespToXapp, 2},
4828         })
4829
4830         // Req1
4831         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4832
4833         //Subs Create
4834         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4835         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4836
4837         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4838
4839         // Req2
4840         params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
4841         params.SetMeid("RAN_NAME_1")
4842
4843         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4844         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4845         crereq, cremsg := e2termConn1.RecvSubsReq(t)
4846         xappConn2.ExpectRESTNotification(t, restSubId2)
4847         e2termConn1.SendSubsResp(t, crereq, cremsg)
4848         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4849
4850         deleteXapp1Subscription(t, &restSubId1)
4851         deleteXapp2Subscription(t, &restSubId2)
4852
4853         waitSubsCleanup(t, e2SubsId1, 10)
4854         waitSubsCleanup(t, e2SubsId2, 10)
4855
4856         mainCtrl.VerifyCounterValues(t)
4857
4858 }
4859
4860 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
4861         CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
4862
4863         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4864                 Counter{cRestSubReqFromXapp, 2},
4865                 Counter{cSubReqToE2, 2},
4866                 Counter{cSubRespFromE2, 2},
4867                 Counter{cRestSubRespToXapp, 2},
4868                 Counter{cRestSubDelReqFromXapp, 2},
4869                 Counter{cSubDelReqToE2, 2},
4870                 Counter{cSubDelRespFromE2, 2},
4871                 Counter{cRestSubDelRespToXapp, 2},
4872         })
4873
4874         // Req1
4875         var params *teststube2ap.RESTSubsReqParams = nil
4876
4877         //Subs Create
4878         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4879         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4880
4881         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4882
4883         // Req2
4884         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4885         params.SetMeid("RAN_NAME_1")
4886         actionDefinition := "5678"
4887         params.SetSubActionDefinition(actionDefinition)
4888
4889         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4890         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4891         crereq, cremsg := e2termConn1.RecvSubsReq(t)
4892         xappConn2.ExpectRESTNotification(t, restSubId2)
4893         e2termConn1.SendSubsResp(t, crereq, cremsg)
4894         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4895
4896         deleteXapp1Subscription(t, &restSubId1)
4897         deleteXapp2Subscription(t, &restSubId2)
4898
4899         waitSubsCleanup(t, e2SubsId1, 10)
4900         waitSubsCleanup(t, e2SubsId2, 10)
4901
4902         mainCtrl.VerifyCounterValues(t)
4903
4904 }
4905
4906 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
4907         CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
4908
4909         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4910                 Counter{cRestSubReqFromXapp, 2},
4911                 Counter{cSubReqToE2, 2},
4912                 Counter{cSubRespFromE2, 2},
4913                 Counter{cRestSubRespToXapp, 2},
4914                 Counter{cRestSubDelReqFromXapp, 2},
4915                 Counter{cSubDelReqToE2, 2},
4916                 Counter{cSubDelRespFromE2, 2},
4917                 Counter{cRestSubDelRespToXapp, 2},
4918         })
4919
4920         // Req1
4921         var params *teststube2ap.RESTSubsReqParams = nil
4922
4923         //Subs Create
4924         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4925         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4926
4927         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4928
4929         // Req2
4930         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4931         params.SetMeid("RAN_NAME_1")
4932         actionDefinition := "56782"
4933         params.SetSubActionDefinition(actionDefinition)
4934
4935         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4936         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4937         crereq, cremsg := e2termConn1.RecvSubsReq(t)
4938         xappConn2.ExpectRESTNotification(t, restSubId2)
4939         e2termConn1.SendSubsResp(t, crereq, cremsg)
4940         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4941
4942         deleteXapp1Subscription(t, &restSubId1)
4943         deleteXapp2Subscription(t, &restSubId2)
4944
4945         waitSubsCleanup(t, e2SubsId1, 10)
4946         waitSubsCleanup(t, e2SubsId2, 10)
4947
4948         mainCtrl.VerifyCounterValues(t)
4949
4950 }
4951
4952 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
4953         CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
4954
4955         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4956                 Counter{cRestSubReqFromXapp, 2},
4957                 Counter{cSubReqToE2, 2},
4958                 Counter{cSubRespFromE2, 2},
4959                 Counter{cRestSubRespToXapp, 2},
4960                 Counter{cRestSubDelReqFromXapp, 2},
4961                 Counter{cSubDelReqToE2, 2},
4962                 Counter{cSubDelRespFromE2, 2},
4963                 Counter{cRestSubDelRespToXapp, 2},
4964         })
4965
4966         // Req1
4967         var params *teststube2ap.RESTSubsReqParams = nil
4968
4969         //Subs Create
4970         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4971         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
4972
4973         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4974
4975         // Req2
4976         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4977         params.SetMeid("RAN_NAME_1")
4978         params.SetTimeToWait("w200ms")
4979         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4980         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4981         crereq, cremsg := e2termConn1.RecvSubsReq(t)
4982         xappConn2.ExpectRESTNotification(t, restSubId2)
4983         e2termConn1.SendSubsResp(t, crereq, cremsg)
4984         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4985
4986         deleteXapp1Subscription(t, &restSubId1)
4987         deleteXapp2Subscription(t, &restSubId2)
4988
4989         waitSubsCleanup(t, e2SubsId1, 10)
4990         waitSubsCleanup(t, e2SubsId2, 10)
4991
4992         mainCtrl.VerifyCounterValues(t)
4993
4994 }
4995
4996 //-----------------------------------------------------------------------------
4997 // TestRESTUnpackSubscriptionResponseDecodeFail
4998 //
4999 //   stub                             stub
5000 // +-------+        +---------+    +---------+
5001 // | xapp  |        | submgr  |    | e2term  |
5002 // +-------+        +---------+    +---------+
5003 //     |                 |              |
5004 //     | RestSubReq      |              |
5005 //     |---------------->|              |
5006 //     |                 |              |
5007 //     |     RESTSubResp |              |
5008 //     |<----------------|              |
5009 //     |                 |              |
5010 //     |                 | SubReq       |
5011 //     |                 |------------->|
5012 //     |                 |              |
5013 //     |                 |      SubResp | ASN.1 decode fails
5014 //     |                 |<-------------|
5015 //     |                 |              |
5016 //     |                 | SubReq       |
5017 //     |                 |------------->|
5018 //     |                 |              |
5019 //     |                 |      SubFail | Duplicated action
5020 //     |                 |<-------------|
5021 //     | RESTNotif (fail)|              |
5022 //     |<----------------|              |
5023 //     |                 | SubDelReq    |
5024 //     |                 |------------->|
5025 //     |                 |              |
5026 //     |                 |   SubDelResp |
5027 //     |                 |<-------------|
5028 //
5029 //-----------------------------------------------------------------------------
5030 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
5031         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
5032         subReqCount := 1
5033
5034         // Req
5035         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5036         restSubId := xappConn1.SendRESTSubsReq(t, params)
5037
5038         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5039         // Decode of this response fails which will result resending original request
5040         e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
5041
5042         _, cremsg = e2termConn1.RecvSubsReq(t)
5043
5044         xappConn1.ExpectRESTNotification(t, restSubId)
5045
5046         // Subscription already created in E2 Node.
5047         fparams := &teststube2ap.E2StubSubsFailParams{}
5048         fparams.Set(crereq)
5049         fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5050         e2termConn1.SendSubsFail(t, fparams, cremsg)
5051
5052         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5053         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5054
5055         instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5056         xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5057
5058         // Wait that subs is cleaned
5059         mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5060
5061         xappConn1.TestMsgChanEmpty(t)
5062         e2termConn1.TestMsgChanEmpty(t)
5063         mainCtrl.wait_registry_empty(t, 10)
5064 }
5065
5066 //-----------------------------------------------------------------------------
5067 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
5068 //
5069 //   stub                             stub
5070 // +-------+        +---------+    +---------+
5071 // | xapp  |        | submgr  |    | e2term  |
5072 // +-------+        +---------+    +---------+
5073 //     |                 |              |
5074 //     | RestSubReq      |              |
5075 //     |---------------->|              |
5076 //     |                 |              |
5077 //     |     RESTSubResp |              |
5078 //     |<----------------|              |
5079 //     |                 |              |
5080 //     |                 | SubReq       |
5081 //     |                 |------------->|
5082 //     |                 |              |
5083 //     |                 |      SubResp | Unknown instanceId
5084 //     |                 |<-------------|
5085 //     |                 |              |
5086 //     |                 | SubReq       |
5087 //     |                 |------------->|
5088 //     |                 |              |
5089 //     |                 |      SubFail | Duplicated action
5090 //     |                 |<-------------|
5091 //     | RESTNotif (fail)|              |
5092 //     |<----------------|              |
5093 //     |                 | SubDelReq    |
5094 //     |                 |------------->|
5095 //     |                 |              |
5096 //     |                 |   SubDelResp |
5097 //     |                 |<-------------|
5098 //
5099 //-----------------------------------------------------------------------------
5100 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
5101         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
5102         subReqCount := 1
5103
5104         // Req
5105         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5106         restSubId := xappConn1.SendRESTSubsReq(t, params)
5107
5108         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5109
5110         // Unknown instanceId in this response which will result resending original request
5111         orgInstanceId := crereq.RequestId.InstanceId
5112         crereq.RequestId.InstanceId = 0
5113         e2termConn1.SendSubsResp(t, crereq, cremsg)
5114
5115         _, cremsg = e2termConn1.RecvSubsReq(t)
5116
5117         xappConn1.ExpectRESTNotification(t, restSubId)
5118
5119         // Subscription already created in E2 Node.
5120         fparams := &teststube2ap.E2StubSubsFailParams{}
5121         fparams.Set(crereq)
5122         fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5123         e2termConn1.SendSubsFail(t, fparams, cremsg)
5124
5125         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5126         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5127
5128         instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5129         xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5130
5131         // Wait that subs is cleaned
5132         mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
5133
5134         xappConn1.TestMsgChanEmpty(t)
5135         e2termConn1.TestMsgChanEmpty(t)
5136         mainCtrl.wait_registry_empty(t, 10)
5137 }
5138
5139 //-----------------------------------------------------------------------------
5140 // TestRESTUnpackSubscriptionResponseNoTransaction
5141 //
5142 //   stub                             stub
5143 // +-------+        +---------+    +---------+
5144 // | xapp  |        | submgr  |    | e2term  |
5145 // +-------+        +---------+    +---------+
5146 //     |                 |              |
5147 //     | RestSubReq      |              |
5148 //     |---------------->|              |
5149 //     |                 |              |
5150 //     |     RESTSubResp |              |
5151 //     |<----------------|              |
5152 //     |                 |              |
5153 //     |                 | SubReq       |
5154 //     |                 |------------->|
5155 //     |                 |              |
5156 //     |                 |      SubResp | No transaction for the response
5157 //     |                 |<-------------|
5158 //     |                 |              |
5159 //     |                 | SubReq       |
5160 //     |                 |------------->|
5161 //     |                 |              |
5162 //     |                 |      SubFail | Duplicated action
5163 //     |                 |<-------------|
5164 //     | RESTNotif (fail)|              |
5165 //     |<----------------|              |
5166 //     |                 | SubDelReq    |
5167 //     |                 |------------->|
5168 //     |                 |              |
5169 //     |                 |   SubDelResp |
5170 //     |                 |<-------------|
5171 //     |                 |              |
5172 //     |                 | SubDelReq    |
5173 //     |                 |------------->|
5174 //     |                 |              |
5175 //     |                 |   SubDelResp |
5176 //     |                 |<-------------|
5177 //
5178 //-----------------------------------------------------------------------------
5179 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
5180         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
5181         subReqCount := 1
5182
5183         // Req
5184         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5185         restSubId := xappConn1.SendRESTSubsReq(t, params)
5186
5187         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5188
5189         mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
5190         // No transaction exist for this response which will result resending original request
5191         e2termConn1.SendSubsResp(t, crereq, cremsg)
5192
5193         _, cremsg = e2termConn1.RecvSubsReq(t)
5194
5195         xappConn1.ExpectRESTNotification(t, restSubId)
5196
5197         // Subscription already created in E2 Node.
5198         fparams := &teststube2ap.E2StubSubsFailParams{}
5199         fparams.Set(crereq)
5200         fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5201         e2termConn1.SendSubsFail(t, fparams, cremsg)
5202
5203         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5204         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5205
5206         // Resending happens because there no transaction
5207         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5208         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5209
5210         instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5211         xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5212
5213         // Wait that subs is cleaned
5214         mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5215
5216         xappConn1.TestMsgChanEmpty(t)
5217         e2termConn1.TestMsgChanEmpty(t)
5218         mainCtrl.wait_registry_empty(t, 10)
5219
5220 }
5221
5222 //-----------------------------------------------------------------------------
5223 // TestRESTUnpackSubscriptionFailureDecodeFail
5224 //
5225 //   stub                             stub
5226 // +-------+        +---------+    +---------+
5227 // | xapp  |        | submgr  |    | e2term  |
5228 // +-------+        +---------+    +---------+
5229 //     |                 |              |
5230 //     | RestSubReq      |              |
5231 //     |---------------->|              |
5232 //     |                 |              |
5233 //     |     RESTSubResp |              |
5234 //     |<----------------|              |
5235 //     |                 |              |
5236 //     |                 | SubReq       |
5237 //     |                 |------------->|
5238 //     |                 |              |
5239 //     |                 |      SubFail | ASN.1 decode fails
5240 //     |                 |<-------------|
5241 //     |                 |              |
5242 //     |                 | SubReq       |
5243 //     |                 |------------->|
5244 //     |                 |              |
5245 //     |                 |      SubFail | Duplicated action
5246 //     |                 |<-------------|
5247 //     | RESTNotif (fail)|              |
5248 //     |<----------------|              |
5249 //     |                 | SubDelReq    |
5250 //     |                 |------------->|
5251 //     |                 |              |
5252 //     |                 |   SubDelResp |
5253 //     |                 |<-------------|
5254 //
5255 //-----------------------------------------------------------------------------
5256 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
5257         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
5258         subReqCount := 1
5259
5260         // Req
5261         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5262         restSubId := xappConn1.SendRESTSubsReq(t, params)
5263
5264         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5265
5266         // Decode of this response fails which will result resending original request
5267         e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
5268
5269         _, cremsg = e2termConn1.RecvSubsReq(t)
5270
5271         xappConn1.ExpectRESTNotification(t, restSubId)
5272
5273         // Subscription already created in E2 Node.
5274         fparams := &teststube2ap.E2StubSubsFailParams{}
5275         fparams.Set(crereq)
5276         fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5277         e2termConn1.SendSubsFail(t, fparams, cremsg)
5278
5279         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5280         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5281
5282         instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5283         xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5284
5285         // Wait that subs is cleaned
5286         mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5287
5288         xappConn1.TestMsgChanEmpty(t)
5289         e2termConn1.TestMsgChanEmpty(t)
5290         mainCtrl.wait_registry_empty(t, 10)
5291 }
5292
5293 //-----------------------------------------------------------------------------
5294 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
5295 //
5296 //   stub                             stub
5297 // +-------+        +---------+    +---------+
5298 // | xapp  |        | submgr  |    | e2term  |
5299 // +-------+        +---------+    +---------+
5300 //     |                 |              |
5301 //     | RestSubReq      |              |
5302 //     |---------------->|              |
5303 //     |                 |              |
5304 //     |     RESTSubResp |              |
5305 //     |<----------------|              |
5306 //     |                 |              |
5307 //     |                 | SubReq       |
5308 //     |                 |------------->|
5309 //     |                 |              |
5310 //     |                 |      SubFail | Unknown instanceId
5311 //     |                 |<-------------|
5312 //     |                 |              |
5313 //     |                 | SubReq       |
5314 //     |                 |------------->|
5315 //     |                 |              |
5316 //     |                 |      SubFail | Duplicated action
5317 //     |                 |<-------------|
5318 //     | RESTNotif (fail)|              |
5319 //     |<----------------|              |
5320 //     |                 | SubDelReq    |
5321 //     |                 |------------->|
5322 //     |                 |              |
5323 //     |                 |   SubDelResp |
5324 //     |                 |<-------------|
5325 //
5326 //-----------------------------------------------------------------------------
5327 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
5328         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
5329         subReqCount := 1
5330
5331         // Req
5332         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5333         restSubId := xappConn1.SendRESTSubsReq(t, params)
5334
5335         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5336
5337         // Unknown instanceId in this response which will result resending original request
5338         fparams := &teststube2ap.E2StubSubsFailParams{}
5339         fparams.Set(crereq)
5340         fparams.Fail.RequestId.InstanceId = 0
5341         e2termConn1.SendSubsFail(t, fparams, cremsg)
5342
5343         _, cremsg = e2termConn1.RecvSubsReq(t)
5344
5345         xappConn1.ExpectRESTNotification(t, restSubId)
5346
5347         // Subscription already created in E2 Node.
5348         fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5349         e2termConn1.SendSubsFail(t, fparams, cremsg)
5350
5351         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5352         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5353
5354         instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5355         xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5356
5357         // Wait that subs is cleaned
5358         mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5359
5360         xappConn1.TestMsgChanEmpty(t)
5361         e2termConn1.TestMsgChanEmpty(t)
5362         mainCtrl.wait_registry_empty(t, 10)
5363 }
5364
5365 //-----------------------------------------------------------------------------
5366 // TestRESTUnpackSubscriptionFailureNoTransaction
5367 //
5368 //   stub                             stub
5369 // +-------+        +---------+    +---------+
5370 // | xapp  |        | submgr  |    | e2term  |
5371 // +-------+        +---------+    +---------+
5372 //     |                 |              |
5373 //     | RestSubReq      |              |
5374 //     |---------------->|              |
5375 //     |                 |              |
5376 //     |     RESTSubResp |              |
5377 //     |<----------------|              |
5378 //     |                 |              |
5379 //     |                 | SubReq       |
5380 //     |                 |------------->|
5381 //     |                 |              |
5382 //     |                 |      SubFail | No transaction for the response
5383 //     |                 |<-------------|
5384 //     |                 |              |
5385 //     |                 | SubReq       |
5386 //     |                 |------------->|
5387 //     |                 |              |
5388 //     |                 |      SubFail | Duplicated action
5389 //     |                 |<-------------|
5390 //     | RESTNotif (fail)|              |
5391 //     |<----------------|              |
5392 //     |                 | SubDelReq    |
5393 //     |                 |------------->|
5394 //     |                 |              |
5395 //     |                 |   SubDelResp |
5396 //     |                 |<-------------|
5397 //
5398 //-----------------------------------------------------------------------------
5399 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
5400         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
5401         subReqCount := 1
5402
5403         // Req
5404         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5405         restSubId := xappConn1.SendRESTSubsReq(t, params)
5406
5407         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5408
5409         mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
5410
5411         // No transaction exist for this response which will result resending original request
5412         fparams := &teststube2ap.E2StubSubsFailParams{}
5413         fparams.Set(crereq)
5414         e2termConn1.SendSubsFail(t, fparams, cremsg)
5415
5416         _, cremsg = e2termConn1.RecvSubsReq(t)
5417
5418         xappConn1.ExpectRESTNotification(t, restSubId)
5419
5420         // Subscription already created in E2 Node.
5421         fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5422         e2termConn1.SendSubsFail(t, fparams, cremsg)
5423
5424         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5425         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5426
5427         // Resending happens because there no transaction
5428         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5429         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5430
5431         instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5432         xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5433
5434         // Wait that subs is cleaned
5435         mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5436
5437         xappConn1.TestMsgChanEmpty(t)
5438         e2termConn1.TestMsgChanEmpty(t)
5439         mainCtrl.wait_registry_empty(t, 10)
5440 }
5441
5442 //-----------------------------------------------------------------------------
5443 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
5444 //
5445 //   stub                             stub
5446 // +-------+        +---------+    +---------+
5447 // | xapp  |        | submgr  |    | e2term  |
5448 // +-------+        +---------+    +---------+
5449 //     |                 |              |
5450 //     |            [SUBS CREATE]       |
5451 //     |                 |              |
5452 //     |                 |              |
5453 //     | RESTSubDelReq   |              |
5454 //     |---------------->|              |
5455 //     |                 |              |
5456 //     |  RESTSubDelResp |              |
5457 //     |<----------------|              |
5458 //     |                 |              |
5459 //     |                 | SubDelReq    |
5460 //     |                 |------------->|
5461 //     |                 |              |
5462 //     |                 |   SubDelResp | ASN.1 decode fails
5463 //     |                 |<-------------|
5464 //     |                 |              |
5465 //     |                 | SubDelReq    |
5466 //     |                 |------------->|
5467 //     |                 |              |
5468 //     |                 |   SubDelFail | Subscription does exist any more
5469 //     |                 |<-------------|
5470 //     |                 |              |
5471 //
5472 //-----------------------------------------------------------------------------
5473 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
5474         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail")
5475
5476         // Req
5477         var params *teststube2ap.RESTSubsReqParams = nil
5478         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5479
5480         // Del
5481         xappConn1.SendRESTSubsDelReq(t, &restSubId)
5482
5483         // E2t: Receive 1st SubsDelReq
5484         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5485
5486         // Decode of this response fails which will result resending original request
5487         e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_REQ)
5488
5489         // E2t: Receive 2nd SubsDelReq and send SubsDelResp
5490         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5491
5492         // Subscription does not exist in in E2 Node.
5493         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5494
5495         // Wait that subs is cleaned
5496         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5497
5498         xappConn1.TestMsgChanEmpty(t)
5499         e2termConn1.TestMsgChanEmpty(t)
5500         mainCtrl.wait_registry_empty(t, 10)
5501 }
5502
5503 //-----------------------------------------------------------------------------
5504 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
5505 //
5506 //   stub                             stub
5507 // +-------+        +---------+    +---------+
5508 // | xapp  |        | submgr  |    | e2term  |
5509 // +-------+        +---------+    +---------+
5510 //     |                 |              |
5511 //     |            [SUBS CREATE]       |
5512 //     |                 |              |
5513 //     |                 |              |
5514 //     | RESTSubDelReq   |              |
5515 //     |---------------->|              |
5516 //     |                 |              |
5517 //     |  RESTSubDelResp |              |
5518 //     |<----------------|              |
5519 //     |                 |              |
5520 //     |                 | SubDelReq    |
5521 //     |                 |------------->|
5522 //     |                 |              |
5523 //     |                 |   SubDelResp | Unknown instanceId
5524 //     |                 |<-------------|
5525 //     |                 |              |
5526 //     |                 | SubDelReq    |
5527 //     |                 |------------->|
5528 //     |                 |              |
5529 //     |                 |   SubDelFail | Subscription does exist any more
5530 //     |                 |<-------------|
5531 //
5532 //-----------------------------------------------------------------------------
5533 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
5534         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId")
5535
5536         // Req
5537         var params *teststube2ap.RESTSubsReqParams = nil
5538         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5539
5540         // Del
5541         xappConn1.SendRESTSubsDelReq(t, &restSubId)
5542
5543         // E2t: Receive 1st SubsDelReq
5544         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5545
5546         // Unknown instanceId in this response which will result resending original request
5547         delreq.RequestId.InstanceId = 0
5548         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5549
5550         // E2t: Receive 2nd SubsDelReq
5551         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5552
5553         // Subscription does not exist in in E2 Node.
5554         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5555
5556         // Wait that subs is cleaned
5557         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5558
5559         xappConn1.TestMsgChanEmpty(t)
5560         e2termConn1.TestMsgChanEmpty(t)
5561         mainCtrl.wait_registry_empty(t, 10)
5562 }
5563
5564 //-----------------------------------------------------------------------------
5565 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
5566 //
5567 //   stub                             stub
5568 // +-------+        +---------+    +---------+
5569 // | xapp  |        | submgr  |    | e2term  |
5570 // +-------+        +---------+    +---------+
5571 //     |                 |              |
5572 //     |            [SUBS CREATE]       |
5573 //     |                 |              |
5574 //     |                 |              |
5575 //     | RESTSubDelReq   |              |
5576 //     |---------------->|              |
5577 //     |                 |              |
5578 //     |  RESTSubDelResp |              |
5579 //     |<----------------|              |
5580 //     |                 |              |
5581 //     |                 | SubDelReq    |
5582 //     |                 |------------->|
5583 //     |                 |              |
5584 //     |                 |   SubDelResp | No transaction for the response
5585 //     |                 |<-------------|
5586 //     |                 |              |
5587 //     |                 | SubDelReq    |
5588 //     |                 |------------->|
5589 //     |                 |              |
5590 //     |                 |   SubDelFail | Subscription does exist any more
5591 //     |                 |<-------------|
5592 //
5593 //-----------------------------------------------------------------------------
5594 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
5595         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction")
5596
5597         // Req
5598         var params *teststube2ap.RESTSubsReqParams = nil
5599         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5600
5601         // Del
5602         xappConn1.SendRESTSubsDelReq(t, &restSubId)
5603
5604         // E2t: Receive 1st SubsDelReq
5605         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5606
5607         mainCtrl.MakeTransactionNil(t, e2SubsId)
5608
5609         // No transaction exist for this response which will result resending original request
5610         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5611
5612         // E2t: Receive 2nd SubsDelReq
5613         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5614
5615         // Subscription does not exist in in E2 Node.
5616         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5617
5618         // Wait that subs is cleaned
5619         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5620
5621         xappConn1.TestMsgChanEmpty(t)
5622         e2termConn1.TestMsgChanEmpty(t)
5623         mainCtrl.wait_registry_empty(t, 10)
5624 }
5625
5626 //-----------------------------------------------------------------------------
5627 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
5628 //
5629 //   stub                             stub
5630 // +-------+        +---------+    +---------+
5631 // | xapp  |        | submgr  |    | e2term  |
5632 // +-------+        +---------+    +---------+
5633 //     |                 |              |
5634 //     |            [SUBS CREATE]       |
5635 //     |                 |              |
5636 //     |                 |              |
5637 //     | RESTSubDelReq   |              |
5638 //     |---------------->|              |
5639 //     |                 |              |
5640 //     |  RESTSubDelResp |              |
5641 //     |<----------------|              |
5642 //     |                 |              |
5643 //     |                 | SubDelReq    |
5644 //     |                 |------------->|
5645 //     |                 |              |
5646 //     |                 |   SubDelFail | ASN.1 decode fails
5647 //     |                 |<-------------|
5648 //     |                 |              |
5649 //     |                 | SubDelReq    |
5650 //     |                 |------------->|
5651 //     |                 |              |
5652 //     |                 |   SubDelFail | Subscription does exist any more
5653 //     |                 |<-------------|
5654 //
5655 //-----------------------------------------------------------------------------
5656 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
5657         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail")
5658
5659         // Req
5660         var params *teststube2ap.RESTSubsReqParams = nil
5661         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5662
5663         // Del
5664         xappConn1.SendRESTSubsDelReq(t, &restSubId)
5665
5666         // E2t: Receive 1st SubsDelReq
5667         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5668
5669         // Decode of this response fails which will result resending original request
5670         e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
5671
5672         // E2t: Receive 2nd SubsDelReq and send SubsDelResp
5673         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5674
5675         // Subscription does not exist in in E2 Node.
5676         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5677
5678         // Wait that subs is cleaned
5679         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5680
5681         xappConn1.TestMsgChanEmpty(t)
5682         e2termConn1.TestMsgChanEmpty(t)
5683         mainCtrl.wait_registry_empty(t, 10)
5684 }
5685
5686 //-----------------------------------------------------------------------------
5687 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
5688 //
5689 //   stub                             stub
5690 // +-------+        +---------+    +---------+
5691 // | xapp  |        | submgr  |    | e2term  |
5692 // +-------+        +---------+    +---------+
5693 //     |                 |              |
5694 //     |            [SUBS CREATE]       |
5695 //     |                 |              |
5696 //     |                 |              |
5697 //     | RESTSubDelReq   |              |
5698 //     |---------------->|              |
5699 //     |                 |              |
5700 //     |  RESTSubDelResp |              |
5701 //     |<----------------|              |
5702 //     |                 |              |
5703 //     |                 | SubDelReq    |
5704 //     |                 |------------->|
5705 //     |                 |              |
5706 //     |                 |   SubDelFail | Unknown instanceId
5707 //     |                 |<-------------|
5708 //     |                 |              |
5709 //     |                 | SubDelReq    |
5710 //     |                 |------------->|
5711 //     |                 |              |
5712 //     |                 |   SubDelFail | Subscription does exist any more
5713 //     |                 |<-------------|
5714 //
5715 //-----------------------------------------------------------------------------
5716 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
5717         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId")
5718
5719         // Req
5720         var params *teststube2ap.RESTSubsReqParams = nil
5721         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5722
5723         // Del
5724         xappConn1.SendRESTSubsDelReq(t, &restSubId)
5725
5726         // E2t: Receive 1st SubsDelReq
5727         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5728
5729         // Unknown instanceId in this response which will result resending original request
5730         delreq.RequestId.InstanceId = 0
5731         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5732
5733         // E2t: Receive 2nd SubsDelReq
5734         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5735
5736         // Subscription does not exist in in E2 Node.
5737         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5738
5739         // Wait that subs is cleaned
5740         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5741
5742         xappConn1.TestMsgChanEmpty(t)
5743         e2termConn1.TestMsgChanEmpty(t)
5744         mainCtrl.wait_registry_empty(t, 10)
5745 }
5746
5747 //-----------------------------------------------------------------------------
5748 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
5749 //
5750 //   stub                             stub
5751 // +-------+        +---------+    +---------+
5752 // | xapp  |        | submgr  |    | e2term  |
5753 // +-------+        +---------+    +---------+
5754 //     |                 |              |
5755 //     |            [SUBS CREATE]       |
5756 //     |                 |              |
5757 //     |                 |              |
5758 //     | RESTSubDelReq   |              |
5759 //     |---------------->|              |
5760 //     |                 |              |
5761 //     |  RESTSubDelResp |              |
5762 //     |<----------------|              |
5763 //     |                 |              |
5764 //     |                 | SubDelReq    |
5765 //     |                 |------------->|
5766 //     |                 |              |
5767 //     |                 |   SubDelFail | No transaction for the response
5768 //     |                 |<-------------|
5769 //     |                 |              |
5770 //     |                 | SubDelReq    |
5771 //     |                 |------------->|
5772 //     |                 |              |
5773 //     |                 |   SubDelFail | Subscription does exist any more
5774 //     |                 |<-------------|
5775 //
5776 //-----------------------------------------------------------------------------
5777 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
5778         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction")
5779
5780         // Req
5781         var params *teststube2ap.RESTSubsReqParams = nil
5782         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5783
5784         // Del
5785         xappConn1.SendRESTSubsDelReq(t, &restSubId)
5786
5787         // E2t: Receive 1st SubsDelReq
5788         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5789
5790         mainCtrl.MakeTransactionNil(t, e2SubsId)
5791
5792         // No transaction exist for this response which will result resending original request
5793         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5794
5795         // E2t: Receive 2nd SubsDelReq
5796         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5797
5798         // Subscription does not exist in in E2 Node.
5799         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5800
5801         // Wait that subs is cleaned
5802         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
5803
5804         xappConn1.TestMsgChanEmpty(t)
5805         e2termConn1.TestMsgChanEmpty(t)
5806         mainCtrl.wait_registry_empty(t, 10)
5807 }
5808
5809 //-----------------------------------------------------------------------------
5810 // TestRESTSubReqFailAsn1PackSubReqError
5811 //
5812 //   stub                             stub
5813 // +-------+        +---------+    +---------+
5814 // | xapp  |        | submgr  |    | e2term  |
5815 // +-------+        +---------+    +---------+
5816 //     |                 |              |
5817 //     | RESTSubReq      |              |
5818 //     |---------------->|              |
5819 //     |                 |              |
5820 //     |     RESTSubResp |              |
5821 //     |<----------------|              |
5822 //     |                 |              |
5823 //     |        ASN.1 encode fails      |
5824 //     |                 |              |
5825 //     |                 | SubDelReq    |
5826 //     |                 |------------->|
5827 //     |                 |              |
5828 //     |                 |  SubDelFail  |
5829 //     |                 |<-------------|
5830 //     |                 |              |
5831 //     |       RESTNotif |              |
5832 //     |       unsuccess |              |
5833 //     |<----------------|              |
5834 //     |                 |              |
5835 //     |            [SUBS DELETE]       |
5836 //     |                 |              |
5837 //
5838 //-----------------------------------------------------------------------------
5839 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
5840
5841         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5842                 Counter{cRestSubReqFromXapp, 1},
5843                 Counter{cSubDelReqToE2, 1},
5844                 Counter{cSubDelFailFromE2, 1},
5845                 Counter{cRestSubFailToXapp, 1},
5846         })
5847
5848         subReqCount := 1
5849
5850         var params *teststube2ap.RESTSubsReqParams = nil
5851         params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
5852         e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
5853
5854         // Req
5855         restSubId := xappConn1.SendRESTSubsReq(t, params)
5856         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
5857
5858         // E2t: Receive SubsDelReq
5859         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5860         xappConn1.ExpectRESTNotification(t, restSubId)
5861
5862         // Subscription does not exist in in E2 Node.
5863         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5864
5865         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
5866         xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
5867
5868         e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
5869         // Wait that subs is cleaned
5870         waitSubsCleanup(t, e2SubsId, 10)
5871         mainCtrl.VerifyCounterValues(t)
5872 }
5873
5874 ////////////////////////////////////////////////////////////////////////////////////
5875 //   Services for UT cases
5876 ////////////////////////////////////////////////////////////////////////////////////
5877 const subReqCount int = 1
5878 const host string = "localhost"
5879
5880 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
5881         if params == nil {
5882                 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
5883         }
5884         restSubId := fromXappConn.SendRESTSubsReq(t, params)
5885         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
5886
5887         crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
5888         fromXappConn.ExpectRESTNotification(t, restSubId)
5889         toE2termConn.SendSubsResp(t, crereq1, cremsg1)
5890         e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
5891         xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
5892
5893         return restSubId, e2SubsId
5894 }
5895
5896 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
5897
5898         params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
5899         if meid != "" {
5900                 params.SetMeid(meid)
5901         }
5902         xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
5903         restSubId := xappConn2.SendRESTSubsReq(t, params)
5904         xappConn2.ExpectRESTNotification(t, restSubId)
5905         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
5906         e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
5907         xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
5908
5909         return restSubId, e2SubsId
5910 }
5911
5912 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
5913         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5914         restSubId := xappConn1.SendRESTSubsReq(t, params)
5915         xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
5916
5917         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
5918         xappConn1.ExpectRESTNotification(t, restSubId)
5919         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
5920         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
5921         xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
5922
5923         return restSubId, e2SubsId
5924 }
5925
5926 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
5927         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5928         restSubId := xappConn1.SendRESTSubsReq(t, params)
5929
5930         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
5931         fparams1 := &teststube2ap.E2StubSubsFailParams{}
5932         fparams1.Set(crereq1)
5933         e2termConn1.SendSubsFail(t, fparams1, cremsg1)
5934
5935         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
5936         xappConn1.ExpectRESTNotification(t, restSubId)
5937         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
5938         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
5939         xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
5940
5941         return restSubId, e2SubsId
5942 }
5943
5944 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
5945         fromXappConn.SendRESTSubsDelReq(t, restSubId)
5946         delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
5947         toE2termConn.SendSubsDelResp(t, delreq, delmsg)
5948 }
5949
5950 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
5951         xappConn1.SendRESTSubsDelReq(t, restSubId)
5952         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5953         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5954 }
5955
5956 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
5957         xappConn2.SendRESTSubsDelReq(t, restSubId)
5958         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5959         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5960 }
5961
5962 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
5963         resp, _ := xapp.Subscription.QuerySubscriptions()
5964         assert.Equal(t, resp[0].SubscriptionID, e2SubsId)
5965         assert.Equal(t, resp[0].Meid, meid)
5966         assert.Equal(t, resp[0].ClientEndpoint, endpoint)
5967 }
5968
5969 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
5970         //Wait that subs is cleaned
5971         mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
5972
5973         xappConn1.TestMsgChanEmpty(t)
5974         xappConn2.TestMsgChanEmpty(t)
5975         e2termConn1.TestMsgChanEmpty(t)
5976         mainCtrl.wait_registry_empty(t, timeout)
5977 }
5978
5979 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
5980
5981         var e2SubsId []uint32
5982
5983         for i := 0; i < count; i++ {
5984                 xapp.Logger.Info("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
5985                 crereq, cremsg := toE2termConn.RecvSubsReq(t)
5986                 fromXappConn.ExpectRESTNotification(t, restSubId)
5987                 toE2termConn.SendSubsResp(t, crereq, cremsg)
5988                 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
5989                 e2SubsId = append(e2SubsId, instanceId)
5990                 xapp.Logger.Info("TEST: %v", e2SubsId)
5991                 xapp.Logger.Info("TEST: %d ===================================== END CRE ============================================", i+1)
5992                 <-time.After(100 * time.Millisecond)
5993         }
5994         return e2SubsId
5995 }
5996
5997 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
5998
5999         for i := 0; i < len(e2SubsIds); i++ {
6000                 xapp.Logger.Info("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
6001                 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
6002                 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
6003                 <-time.After(1 * time.Second)
6004                 xapp.Logger.Info("TEST: %d ===================================== END DEL ============================================", i+1)
6005                 <-time.After(100 * time.Millisecond)
6006         }
6007
6008         // Wait that subs is cleaned
6009         for i := 0; i < len(e2SubsIds); i++ {
6010                 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)
6011         }
6012
6013 }