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