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.
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 //-----------------------------------------------------------------------------
2646 //   stub                             stub          stub
2647 // +-------+        +---------+    +---------+   +---------+
2648 // | xapp  |        | submgr  |    | e2term  |   |  rtmgr  |
2649 // +-------+        +---------+    +---------+   +---------+
2650 //     |                 |              |             |
2651 //     | RESTSubReq      |              |             |
2652 //     |---------------->|              |             |
2653 //     |     RESTSubResp |              |             |
2654 //     |<----------------|              |             |
2655 //     |                 | RouteCreate  |             |
2656 //     |                 |--------------------------->|
2657 //     |                 | RouteResponse|             |
2658 //     |                 |<---------------------------|  // The order of these events may vary
2659 //     |                 | SubReq       |             |
2660 //     |                 |------------->|             |  // The order of these events may vary
2661 //     |                 |      SubResp |             |
2662 //     |                 |<-------------|             |
2663 //     |      RESTNotif1 |              |             |
2664 //     |<----------------|              |             |
2665 //     | RESTSubReq      |              |             |
2666 //     | [RETRANS1]      |              |             |
2667 //     |---------------->|              |             |
2668 //     |      RESTNotif1 |              |             |
2669 //     |<----------------|              |             |
2670 //     | RESTSubReq      |              |             |
2671 //     | [RETRANS2]      |              |             |
2672 //     |---------------->|              |             |
2673 //     |      RESTNotif1 |              |             |
2674 //     |<----------------|              |             |
2675 //     | RESTSubDelReq   |              |             |
2676 //     |---------------->|              |             |
2677 //     |                 | SubDelReq    |             |
2678 //     |                 |------------->|             |
2679 //     |   RESTSubDelResp|              |             |
2680 //     |<----------------|              |             |
2681 //     |                 |   SubDelResp |             |
2682 //     |                 |<-------------|             |
2683 //     |                 |              |             |
2684 //
2685 //-----------------------------------------------------------------------------
2686
2687 func TestRESTSubReqRetransmissionV2(t *testing.T) {
2688         CaseBegin("TestRESTSubReqRetransmissionV2")
2689
2690         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2691                 Counter{cRestSubReqFromXapp, 3},
2692                 Counter{cRestSubRespToXapp, 3},
2693                 Counter{cSubReqToE2, 1},
2694                 Counter{cSubRespFromE2, 1},
2695                 Counter{cRestSubNotifToXapp, 3},
2696                 Counter{cRestSubDelReqFromXapp, 1},
2697                 Counter{cSubDelReqToE2, 1},
2698                 Counter{cSubDelRespFromE2, 1},
2699                 Counter{cRestSubDelRespToXapp, 1},
2700         })
2701
2702         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2703
2704         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2705
2706         queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2707
2708         //1.st resend
2709         restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
2710
2711         assert.Equal(t, restSubId_resend, restSubId)
2712
2713         <-time.After(100 * time.Millisecond)
2714
2715         //2.nd resend
2716         restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
2717
2718         assert.Equal(t, restSubId_resend2, restSubId)
2719
2720         <-time.After(100 * time.Millisecond)
2721
2722         deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2723
2724         waitSubsCleanup(t, e2SubsId, 10)
2725
2726         //Wait that subs is cleaned
2727         mainCtrl.VerifyCounterValues(t)
2728 }
2729
2730 //-----------------------------------------------------------------------------
2731 //   stub                             stub          stub
2732 // +-------+        +---------+    +---------+   +---------+
2733 // | xapp  |        | submgr  |    | e2term  |   |  rtmgr  |
2734 // +-------+        +---------+    +---------+   +---------+
2735 //     |                 |              |             |
2736 //     | RESTSubReq      |              |             |
2737 //     |---------------->|              |             |
2738 //     |     RESTSubResp |              |             |
2739 //     |<----------------|              |             |
2740 //     |                 | RouteCreate  |             |
2741 //     |                 |--------------------------->|
2742 //     |                 | RouteResponse|             |
2743 //     |                 |<---------------------------|  // The order of these events may vary
2744 //     |                 | SubReq       |             |
2745 //     |                 |------------->|             |  // The order of these events may vary
2746 //     |                 |      SubResp |             |
2747 //     |                 |<-------------|             |
2748 //     |      RESTNotif1 |              |             |
2749 //     |<----------------|              |             |
2750 //     | RESTSubReq      |              |             |
2751 //     | [RETRANS, with RESTsubsId]     |             |
2752 //     |---------------->|              |             |
2753 //     |      RESTNotif1 |              |             |
2754 //     |<----------------|              |             |
2755 //     | RESTSubReq      |              |             |
2756 //     | [RETRANS, without RESTsubsId]  |             |
2757 //     |---------------->|              |             |
2758 //     |      RESTNotif1 |              |             |
2759 //     |<----------------|              |             |
2760 //     | RESTSubDelReq   |              |             |
2761 //     |---------------->|              |             |
2762 //     |                 | SubDelReq    |             |
2763 //     |                 |------------->|             |
2764 //     |   RESTSubDelResp|              |             |
2765 //     |<----------------|              |             |
2766 //     |                 |   SubDelResp |             |
2767 //     |                 |<-------------|             |
2768 //     |                 |              |             |
2769 //
2770 //-----------------------------------------------------------------------------
2771 func TestRESTSubReqRetransmissionV3(t *testing.T) {
2772         CaseBegin("TestRESTSubReqRetransmissionV3")
2773
2774         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2775                 Counter{cRestSubReqFromXapp, 3},
2776                 Counter{cRestSubRespToXapp, 3},
2777                 Counter{cSubReqToE2, 1},
2778                 Counter{cSubRespFromE2, 1},
2779                 Counter{cRestSubNotifToXapp, 3},
2780                 Counter{cRestSubDelReqFromXapp, 1},
2781                 Counter{cSubDelReqToE2, 1},
2782                 Counter{cSubDelRespFromE2, 1},
2783                 Counter{cRestSubDelRespToXapp, 1},
2784         })
2785
2786         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2787
2788         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2789
2790         queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2791
2792         <-time.After(100 * time.Millisecond)
2793
2794         //1.st resend with subscription ID
2795         params.SetSubscriptionID(&restSubId)
2796         restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
2797
2798         assert.Equal(t, restSubId_resend, restSubId)
2799
2800         <-time.After(100 * time.Millisecond)
2801
2802         //2.nd resend without subscription ID (faking app restart)
2803         params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
2804         restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
2805
2806         assert.Equal(t, restSubId_resend2, restSubId)
2807
2808         <-time.After(100 * time.Millisecond)
2809
2810         deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2811
2812         waitSubsCleanup(t, e2SubsId, 10)
2813
2814         //Wait that subs is cleaned
2815         mainCtrl.VerifyCounterValues(t)
2816 }
2817
2818 //-----------------------------------------------------------------------------
2819 //   stub                             stub          stub
2820 // +-------+        +---------+    +---------+   +---------+
2821 // | xapp  |        | submgr  |    | e2term  |   |  rtmgr  |
2822 // +-------+        +---------+    +---------+   +---------+
2823 //     |                 |              |             |
2824 //     | RESTSubReq      |              |             |
2825 //     |---------------->|              |             |
2826 //     |     RESTSubResp |              |             |
2827 //     |<----------------|              |             |
2828 //     |                 | RouteCreate  |             |
2829 //     |                 |--------------------------->|
2830 //     |                 | RouteResponse|             |
2831 //     |                 |<---------------------------|
2832 //     |                 | SubReq       |             |
2833 //     |                 |------------->|             |
2834 //     |                 |      SubResp |             |
2835 //     |                 |<-------------|             |
2836 //     |      RESTNotif1 |              |             |
2837 //     |<----------------|              |             |
2838 //     | RESTSubReq      |              |             |
2839 //     | [with RestSUbsId + one additional e2 subDetail]
2840 //     |---------------->|              |             |
2841 //     |      RESTNotif1 |              |             |
2842 //     | [for initial e2 subDetail]     |             |
2843 //     |<----------------|              |             |
2844 //     |                 | RouteCreate  |             |
2845 //     |                 |--------------------------->|
2846 //     |                 | RouteResponse|             |
2847 //     |                 |<---------------------------|
2848 //     |                 | SubReq       |             |
2849 //     |                 |------------->|             |
2850 //     |                 |      SubResp |             |
2851 //     |                 |<-------------|             |
2852 //     |      RESTNotif1 |              |             |
2853 //     |<----------------|              |             |
2854 //     | RESTSubReq      |              |             |
2855 //     | [with RESTsubsId initial request]            |
2856 //     |---------------->|              |             |
2857 //     |      RESTNotif1 |              |             |
2858 //     |<----------------|              |             |
2859 //     | RESTSubDelReq   |              |             |
2860 //     |---------------->|              |             |
2861 //     |   RESTSubDelResp|              |             |
2862 //     |<----------------|              |             |
2863 //     |                 | SubDelReq    |             |
2864 //     |                 |------------->|             |
2865 //     |                 |   SubDelResp |             |
2866 //     |                 |<-------------|             |
2867 //     |                 | SubDelReq    |             |
2868 //     |                 |------------->|             |
2869 //     |                 |   SubDelResp |             |
2870 //     |                 |<-------------|             |
2871 //     |                 |              |             |
2872 //
2873 //-----------------------------------------------------------------------------
2874
2875 func TestRESTSubReqRetransmissionV4(t *testing.T) {
2876         CaseBegin("TestRESTSubReqRetransmissionV4")
2877
2878         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2879                 Counter{cRestSubReqFromXapp, 3},
2880                 Counter{cRestSubRespToXapp, 3},
2881                 Counter{cSubReqToE2, 2},
2882                 Counter{cSubRespFromE2, 2},
2883                 Counter{cRestSubNotifToXapp, 4},
2884                 Counter{cRestSubDelReqFromXapp, 1},
2885                 Counter{cSubDelReqToE2, 2},
2886                 Counter{cSubDelRespFromE2, 2},
2887                 Counter{cRestSubDelRespToXapp, 1},
2888         })
2889
2890         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2891
2892         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2893
2894         <-time.After(100 * time.Millisecond)
2895
2896         // Send modified  requst, this time with e2 subscriptions.
2897         params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
2898         params2.SetSubscriptionID(&restSubId)
2899
2900         xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
2901         xappConn1.WaitRESTNotificationForAnySubscriptionId(t)
2902         // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
2903         restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
2904
2905         crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
2906
2907         xappConn1.ExpectRESTNotification(t, restSubId_resend)
2908         e2termConn1.SendSubsResp(t, crereq2, cremsg2)
2909         e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
2910         assert.NotEqual(t, e2SubsId2, 0)
2911
2912         <-time.After(100 * time.Millisecond)
2913
2914         xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
2915         params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
2916         params.SetSubscriptionID(&restSubId)
2917         xappConn1.WaitRESTNotificationForAnySubscriptionId(t)
2918         // Resend the original request again with only one e2 subscription (detail), this time with restsubsid
2919         restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
2920         assert.Equal(t, restSubId_resend, restSubId_resend2)
2921
2922         // Delete both e2 subscriptions
2923         xappConn1.SendRESTSubsDelReq(t, &restSubId)
2924         e2SubsIds := []uint32{e2SubsId, e2SubsId2}
2925         sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
2926
2927         waitSubsCleanup(t, e2SubsId, 10)
2928
2929         //Wait that subs is cleaned
2930         mainCtrl.VerifyCounterValues(t)
2931 }
2932
2933 //-----------------------------------------------------------------------------
2934 //   stub                             stub          stub
2935 // +-------+        +---------+    +---------+   +---------+
2936 // | xapp  |        | submgr  |    | e2term  |   |  rtmgr  |
2937 // +-------+        +---------+    +---------+   +---------+
2938 //     |                 |              |             |
2939 //     | RESTSubReq      |              |             |
2940 //     |---------------->|              |             |
2941 //     |     RESTSubResp |              |             |
2942 //     |<----------------|              |             |
2943 //     |                 | RouteCreate  |             |
2944 //     |                 |--------------------------->|
2945 //     |                 | RouteResponse|             |
2946 //     |                 |<---------------------------|
2947 //     |                 | SubReq       |             |
2948 //     |                 |------------->|             |
2949 //     |                 |      SubResp |             |
2950 //     |                 |<-------------|             |
2951 //     |      RESTNotif1 |              |             |
2952 //     |<----------------|              |             |
2953 //     | RESTSubReq      |              |             |
2954 //     | [with RestSUbsId + one additional e2 subDetail]
2955 //     |---------------->|              |             |
2956 //     |      RESTNotif1 |              |             |
2957 //     | [for initial e2 subDetail]     |             |
2958 //     |<----------------|              |             |
2959 //     |                 | RouteCreate  |             |
2960 //     |                 |--------------------------->|
2961 //     |                 | RouteResponse|             |
2962 //     |                 |<---------------------------|
2963 //     |                 | SubReq       |             |
2964 //     |                 |------------->|             |
2965 //     |                 |      SubResp |             |
2966 //     |                 |<-------------|             |
2967 //     |      RESTNotif1 |              |             |
2968 //     |<----------------|              |             |
2969 //     | RESTSubReq      |              |             |
2970 //     | [without RESTsubsId initial request]         |
2971 //     |---------------->|              |             |
2972 //     |      RESTNotif1 |              |             |
2973 //     |<----------------|              |             |
2974 //     | RESTSubDelReq   |              |             |
2975 //     |---------------->|              |             |
2976 //     |   RESTSubDelResp|              |             |
2977 //     |<----------------|              |             |
2978 //     |                 | SubDelReq    |             |
2979 //     |                 |------------->|             |
2980 //     |                 |   SubDelResp |             |
2981 //     |                 |<-------------|             |
2982 //     |                 | SubDelReq    |             |
2983 //     |                 |------------->|             |
2984 //     |                 |   SubDelResp |             |
2985 //     |                 |<-------------|             |
2986 //     |                 |              |             |
2987 //
2988 //-----------------------------------------------------------------------------
2989
2990 func TestRESTSubReqRetransmissionV5(t *testing.T) {
2991         CaseBegin("TestRESTSubReqRetransmissionV5")
2992
2993         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2994                 Counter{cRestSubReqFromXapp, 3},
2995                 Counter{cRestSubRespToXapp, 3},
2996                 Counter{cSubReqToE2, 2},
2997                 Counter{cSubRespFromE2, 2},
2998                 Counter{cRestSubNotifToXapp, 4},
2999                 Counter{cRestSubDelReqFromXapp, 1},
3000                 Counter{cSubDelReqToE2, 2},
3001                 Counter{cSubDelRespFromE2, 2},
3002                 Counter{cRestSubDelRespToXapp, 1},
3003         })
3004
3005         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3006
3007         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3008
3009         <-time.After(100 * time.Millisecond)
3010
3011         // Send modified  requst, this time with e2 subscriptions.
3012         params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3013         params2.SetSubscriptionID(&restSubId)
3014
3015         xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3016         xappConn1.WaitRESTNotificationForAnySubscriptionId(t)
3017         // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3018         restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3019
3020         crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3021
3022         xappConn1.ExpectRESTNotification(t, restSubId_resend)
3023         e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3024         e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3025         assert.NotEqual(t, e2SubsId2, 0)
3026
3027         <-time.After(100 * time.Millisecond)
3028
3029         xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3030         params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3031         xappConn1.WaitRESTNotificationForAnySubscriptionId(t)
3032         // Resend the original request again with only one e2 subscription (detail), WITHOUT restsubsid
3033         // md5sum shall find the original request
3034         restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3035         assert.Equal(t, restSubId_resend, restSubId_resend2)
3036
3037         // Delete both e2 subscriptions
3038         xappConn1.SendRESTSubsDelReq(t, &restSubId)
3039         e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3040         sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3041
3042         waitSubsCleanup(t, e2SubsId, 10)
3043
3044         //Wait that subs is cleaned
3045         mainCtrl.VerifyCounterValues(t)
3046 }
3047
3048 //-----------------------------------------------------------------------------
3049 //   stub                             stub          stub
3050 // +-------+        +---------+    +---------+   +---------+
3051 // | xapp  |        | submgr  |    | e2term  |   |  rtmgr  |
3052 // +-------+        +---------+    +---------+   +---------+
3053 //     |                 |              |             |
3054 //     | RESTSubReq      |              |             |
3055 //     |---------------->|              |             |
3056 //     |     RESTSubResp |              |             |
3057 //     |<----------------|              |             |
3058 //     |                 | RouteCreate  |             |
3059 //     |                 |--------------------------->|
3060 //     |                 | RouteResponse|             |
3061 //     |                 |<---------------------------|
3062 //     |                 | SubReq       |             |
3063 //     |                 |------------->|             |
3064 //     |                 |      SubResp |             |
3065 //     |                 |<-------------|             |
3066 //     |      RESTNotif1 |              |             |
3067 //     |<----------------|              |             |
3068 //     | RESTSubReq      |              |             |
3069 //     | [with RestSUbsId + one additional e2 subDetail]
3070 //     |---------------->|              |             |
3071 //     |      RESTNotif1 |              |             |
3072 //     | [for initial e2 subDetail]     |             |
3073 //     |<----------------|              |             |
3074 //     |                 | RouteCreate  |             |
3075 //     |                 |--------------------------->|
3076 //     |                 | RouteResponse|             |
3077 //     |                 |<---------------------------|
3078 //     |                 | SubReq       |             |
3079 //     |                 |------------->|             |
3080 //     |                 |      SubResp |             |
3081 //     |                 |<-------------|             |
3082 //     |      RESTNotif1 |              |             |
3083 //     |<----------------|              |             |
3084 //     | RESTSubDelReq   |              |             |
3085 //     |---------------->|              |             |
3086 //     |   RESTSubDelResp|              |             |
3087 //     |<----------------|              |             |
3088 //     |                 | SubDelReq    |             |
3089 //     |                 |------------->|             |
3090 //     |                 |   SubDelResp |             |
3091 //     |                 |<-------------|             |
3092 //     |                 | SubDelReq    |             |
3093 //     |                 |------------->|             |
3094 //     |                 |   SubDelResp |             |
3095 //     |                 |<-------------|             |
3096 //     | RESTSubReq      |              |             |
3097 //     | [with RESTsubsId initial request]            |
3098 //     |---------------->|              |             |
3099 //     |     RESTSubResp |              |             |
3100 //     |<----------------|              |             |
3101 //     |                 | RouteCreate  |             |
3102 //     |                 |--------------------------->|
3103 //     |                 | RouteResponse|             |
3104 //     |                 |<---------------------------|
3105 //     |                 | SubReq       |             |
3106 //     |                 |------------->|             |
3107 //     |                 |      SubResp |             |
3108 //     |                 |<-------------|             |
3109 //     |      RESTNotif1 |              |             |
3110 //     |<----------------|              |             |
3111 //     |                 |              |             |
3112 //
3113 //-----------------------------------------------------------------------------
3114 func TestRESTSubReqRetransmissionV6(t *testing.T) {
3115         CaseBegin("TestRESTSubReqRetransmissionV6")
3116
3117         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3118                 Counter{cRestSubReqFromXapp, 3},
3119                 Counter{cRestSubRespToXapp, 3},
3120                 Counter{cSubReqToE2, 3},
3121                 Counter{cSubRespFromE2, 3},
3122                 Counter{cRestSubNotifToXapp, 4},
3123                 Counter{cRestSubDelReqFromXapp, 2},
3124                 Counter{cSubDelReqToE2, 3},
3125                 Counter{cSubDelRespFromE2, 3},
3126                 Counter{cRestSubDelRespToXapp, 2},
3127         })
3128
3129         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3130
3131         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3132
3133         <-time.After(100 * time.Millisecond)
3134
3135         // Send modified  requst, this time with e2 subscriptions.
3136         params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3137         params2.SetSubscriptionID(&restSubId)
3138
3139         xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3140         xappConn1.WaitRESTNotificationForAnySubscriptionId(t)
3141         // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3142         restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3143
3144         crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3145
3146         xappConn1.ExpectRESTNotification(t, restSubId_resend)
3147         e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3148         e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3149         assert.NotEqual(t, e2SubsId2, 0)
3150
3151         <-time.After(100 * time.Millisecond)
3152
3153         // Delete both e2 subscriptions
3154         xappConn1.SendRESTSubsDelReq(t, &restSubId)
3155         e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3156         sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3157
3158         waitSubsCleanup(t, e2SubsId, 10)
3159
3160         // Resend the original request, we shall find it's previous md5sum/restsubs
3161         // but the restsubscription has been already removed. This shall trigger a
3162         // fresh create.
3163         restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
3164
3165         <-time.After(100 * time.Millisecond)
3166
3167         deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3168
3169         waitSubsCleanup(t, e2SubsId, 10)
3170
3171         //Wait that subs is cleaned
3172         mainCtrl.VerifyCounterValues(t)
3173 }
3174
3175 func TestRESTSubDelReqRetransmission(t *testing.T) {
3176         CaseBegin("TestRESTSubDelReqRetransmission")
3177
3178         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3179                 Counter{cRestSubReqFromXapp, 1},
3180                 Counter{cRestSubRespToXapp, 1},
3181                 Counter{cSubReqToE2, 1},
3182                 Counter{cSubRespFromE2, 1},
3183                 Counter{cRestSubNotifToXapp, 1},
3184                 Counter{cRestSubDelReqFromXapp, 2},
3185                 Counter{cSubDelReqToE2, 1},
3186                 Counter{cSubDelRespFromE2, 1},
3187                 Counter{cRestSubDelRespToXapp, 1},
3188         })
3189
3190         var params *teststube2ap.RESTSubsReqParams = nil
3191
3192         //Subs Create
3193         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3194
3195         queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3196
3197         //Subs Delete
3198         xappConn1.SendRESTSubsDelReq(t, &restSubId)
3199         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3200
3201         seqBef := mainCtrl.get_msgcounter(t)
3202         xappConn1.SendRESTSubsDelReq(t, &restSubId)
3203         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
3204
3205         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3206
3207         waitSubsCleanup(t, e2SubsId, 10)
3208
3209         mainCtrl.VerifyCounterValues(t)
3210 }
3211
3212 //-----------------------------------------------------------------------------
3213 // TestRESTSubReqDelReq
3214 //
3215 //   stub                             stub
3216 // +-------+        +---------+    +---------+
3217 // | xapp  |        | submgr  |    | e2term  |
3218 // +-------+        +---------+    +---------+
3219 //     |                 |              |
3220 //     | RESTSubReq      |              |
3221 //     |---------------->|              |
3222 //     |                 |              |
3223 //     |     RESTSubResp |              |
3224 //     |<----------------|              |
3225 //     |                 | SubReq       |
3226 //     |                 |------------->|
3227 //     | RESTSubDelReq   |              |
3228 //     |---------------->|              |
3229 //     |  RESTSubDelResp |              |
3230 //     |     unsuccess   |              |
3231 //     |<----------------|              |
3232 //     |                 |      SubResp |
3233 //     |                 |<-------------|
3234 //     |      RESTNotif1 |              |
3235 //     |<----------------|              |
3236 //     |                 |              |
3237 //     |            [SUBS DELETE]       |
3238 //     |                 |              |
3239 //
3240 //-----------------------------------------------------------------------------
3241 func TestRESTSubReqDelReq(t *testing.T) {
3242         CaseBegin("TestRESTSubReqDelReq")
3243
3244         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3245                 Counter{cRestSubReqFromXapp, 1},
3246                 Counter{cRestSubRespToXapp, 1},
3247                 Counter{cSubReqToE2, 1},
3248                 Counter{cSubRespFromE2, 1},
3249                 Counter{cRestSubNotifToXapp, 1},
3250                 Counter{cRestSubDelReqFromXapp, 2},
3251                 Counter{cSubDelReqToE2, 1},
3252                 Counter{cSubDelRespFromE2, 1},
3253                 Counter{cRestSubDelRespToXapp, 1},
3254         })
3255
3256         const subReqCount int = 1
3257
3258         // Req
3259         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3260         restSubId := xappConn1.SendRESTSubsReq(t, params)
3261
3262         // Del. This will fail as processing of the subscription
3263         // is still ongoing in submgr. Deletion is not allowed before
3264         // subscription creation has been completed.
3265         xappConn1.SendRESTSubsDelReq(t, &restSubId)
3266         crereq, cremsg := e2termConn1.RecvSubsReq(t)
3267         xappConn1.ExpectRESTNotification(t, restSubId)
3268         e2termConn1.SendSubsResp(t, crereq, cremsg)
3269         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3270
3271         // Retry del
3272         xappConn1.SendRESTSubsDelReq(t, &restSubId)
3273
3274         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3275         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3276
3277         // Wait that subs is cleaned
3278         waitSubsCleanup(t, e2SubsId, 10)
3279         mainCtrl.VerifyCounterValues(t)
3280
3281 }
3282
3283 func TestRESTSubDelReqCollision(t *testing.T) {
3284         CaseBegin("TestRESTSubDelReqCollision - not relevant for REST API")
3285 }
3286
3287 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
3288         CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel")
3289
3290         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3291                 Counter{cRestSubReqFromXapp, 2},
3292                 Counter{cRestSubRespToXapp, 2},
3293                 Counter{cSubReqToE2, 2},
3294                 Counter{cSubRespFromE2, 2},
3295                 Counter{cRestSubNotifToXapp, 2},
3296                 Counter{cRestSubDelReqFromXapp, 2},
3297                 Counter{cSubDelReqToE2, 2},
3298                 Counter{cSubDelRespFromE2, 2},
3299                 Counter{cRestSubDelRespToXapp, 2},
3300         })
3301
3302         //Req1
3303         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3304         restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3305         xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3306
3307         //Req2
3308         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3309         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3310         xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3311
3312         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3313         crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3314
3315         //XappConn1 receives both of the  responses
3316         xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3317
3318         //Resp1
3319         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3320         //Resp2
3321         e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3322
3323         e2SubsIdA := <-xappConn1.ListedRESTNotifications
3324         xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3325         e2SubsIdB := <-xappConn1.ListedRESTNotifications
3326         xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3327
3328         //Del1
3329         deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3330         //Del2
3331         deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
3332
3333         //Wait that subs is cleaned
3334         mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
3335         waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
3336
3337         mainCtrl.VerifyCounterValues(t)
3338
3339 }
3340
3341 func TestRESTSameSubsDiffRan(t *testing.T) {
3342         CaseBegin("TestRESTSameSubsDiffRan")
3343
3344         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3345                 Counter{cRestSubReqFromXapp, 2},
3346                 Counter{cRestSubRespToXapp, 2},
3347                 Counter{cSubReqToE2, 2},
3348                 Counter{cSubRespFromE2, 2},
3349                 Counter{cRestSubNotifToXapp, 2},
3350                 Counter{cRestSubDelReqFromXapp, 2},
3351                 Counter{cSubDelReqToE2, 2},
3352                 Counter{cSubDelRespFromE2, 2},
3353                 Counter{cRestSubDelRespToXapp, 2},
3354         })
3355
3356         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3357         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3358         xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3359
3360         params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3361         params.SetMeid("RAN_NAME_2")
3362         restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
3363         xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3364
3365         //Del1
3366         deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3367         //Del2
3368         deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
3369
3370         //Wait that subs is cleaned
3371         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3372         waitSubsCleanup(t, e2SubsId2, 10)
3373
3374         mainCtrl.VerifyCounterValues(t)
3375
3376 }
3377
3378 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
3379         CaseBegin("TestRESTSubReqRetryInSubmgr start")
3380
3381         // Init counter check
3382         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3383                 Counter{cRestSubReqFromXapp, 1},
3384                 Counter{cRestSubRespToXapp, 1},
3385                 Counter{cSubReqToE2, 1},
3386                 Counter{cSubReReqToE2, 1},
3387                 Counter{cSubRespFromE2, 1},
3388                 Counter{cRestSubNotifToXapp, 1},
3389                 Counter{cRestSubDelReqFromXapp, 1},
3390                 Counter{cSubDelReqToE2, 1},
3391                 Counter{cSubDelRespFromE2, 1},
3392                 Counter{cRestSubDelRespToXapp, 1},
3393         })
3394
3395         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3396         restSubId := xappConn1.SendRESTSubsReq(t, params)
3397
3398         xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
3399
3400         // Catch the first message and ignore it
3401         crereq, cremsg := e2termConn1.RecvSubsReq(t)
3402         xapp.Logger.Info("Ignore REST subscriber request for subscriber : %v", restSubId)
3403
3404         // The second request is being handled normally
3405         crereq, cremsg = e2termConn1.RecvSubsReq(t)
3406         xappConn1.ExpectRESTNotification(t, restSubId)
3407         e2termConn1.SendSubsResp(t, crereq, cremsg)
3408         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3409
3410         queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3411
3412         deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3413
3414         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
3415         //Wait that subs is cleaned
3416         waitSubsCleanup(t, e2SubsId, 10)
3417
3418         mainCtrl.VerifyCounterValues(t)
3419
3420 }
3421
3422 //-----------------------------------------------------------------------------
3423 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3424 //
3425 //   stub                             stub
3426 // +-------+        +---------+    +---------+
3427 // | xapp  |        | submgr  |    | e2term  |
3428 // +-------+        +---------+    +---------+
3429 //     |                 |              |
3430 //     | RESTSubReq      |              |
3431 //     |---------------->|              |
3432 //     |                 |              |
3433 //     |     RESTSubResp |              |
3434 //     |<----------------|              |
3435 //     |                 | SubReq       |
3436 //     |                 |------------->|
3437 //     |                 |              |
3438 //     |                 |              |
3439 //     |                 | SubReq       |
3440 //     |                 |------------->|
3441 //     |                 |              |
3442 //     |                 | SubDelReq    |
3443 //     |                 |------------->|
3444 //     |                 |              |
3445 //     |                 |              |
3446 //     |                 | SubDelReq    |
3447 //     |                 |------------->|
3448 //     |                 |              |
3449 //     |                 |              |
3450 //     |                 |   SubDelResp |
3451 //     |                 |<-------------|
3452 //     |       RESTNotif |              |
3453 //     |       unsuccess |              |
3454 //     |<----------------|              |
3455 //     |                 |              |
3456 //     |            [SUBS DELETE]       |
3457 //     |                 |              |
3458 //
3459 //-----------------------------------------------------------------------------
3460
3461 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
3462         CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
3463
3464         // Init counter check
3465         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3466                 Counter{cRestSubReqFromXapp, 1},
3467                 Counter{cRestSubRespToXapp, 1},
3468                 Counter{cSubReqToE2, 1},
3469                 Counter{cSubReReqToE2, 1},
3470                 Counter{cSubReqTimerExpiry, 2},
3471                 Counter{cSubDelReqToE2, 1},
3472                 Counter{cSubDelRespFromE2, 1},
3473         })
3474
3475         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3476         restSubId := xappConn1.SendRESTSubsReq(t, params)
3477         xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
3478
3479         e2termConn1.RecvSubsReq(t)
3480         xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3481
3482         e2termConn1.RecvSubsReq(t)
3483         xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3484
3485         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3486         xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3487         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3488         xappConn1.WaitRESTNotification(t, restSubId)
3489
3490         // Wait that subs is cleaned
3491         waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
3492
3493         mainCtrl.VerifyCounterValues(t)
3494 }
3495
3496 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
3497         CaseBegin("TestREST2eTermNotRespondingToSubReq start")
3498
3499         // Init counter check
3500         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3501                 Counter{cRestSubReqFromXapp, 1},
3502                 Counter{cRestSubRespToXapp, 1},
3503                 Counter{cSubReqToE2, 1},
3504                 Counter{cSubReReqToE2, 1},
3505                 Counter{cSubReqTimerExpiry, 2},
3506                 Counter{cSubDelReqToE2, 1},
3507                 Counter{cSubDelReqTimerExpiry, 2},
3508         })
3509
3510         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3511         restSubId := xappConn1.SendRESTSubsReq(t, params)
3512         xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
3513
3514         e2termConn1.RecvSubsReq(t)
3515         xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3516
3517         e2termConn1.RecvSubsReq(t)
3518         xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3519
3520         e2termConn1.RecvSubsDelReq(t)
3521         xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3522
3523         xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3524         e2termConn1.RecvSubsDelReq(t)
3525         xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3526
3527         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3528
3529         waitSubsCleanup(t, e2SubsId, 10)
3530
3531         mainCtrl.VerifyCounterValues(t)
3532
3533 }
3534
3535 //-----------------------------------------------------------------------------
3536 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3537 //
3538 //   stub                             stub
3539 // +-------+        +---------+    +---------+
3540 // | xapp  |        | submgr  |    | e2term  |
3541 // +-------+        +---------+    +---------+
3542 //     |                 |              |
3543 //     | RESTSubReq      |              |
3544 //     |---------------->|              |
3545 //     |                 |              |
3546 //     |     RESTSubResp |              |
3547 //     |<----------------|              |
3548 //     |                 | SubReq       |
3549 //     |                 |------------->|
3550 //     |                 |              |
3551 //     |                 |              |
3552 //     |                 | SubReq       |
3553 //     |                 |------------->|
3554 //     |                 |              |
3555 //     |                 | SubDelReq    |
3556 //     |                 |------------->|
3557 //     |                 |              |
3558 //     |                 |              |
3559 //     |                 | SubDelReq    |
3560 //     |                 |------------->|
3561 //     |                 |              |
3562 //     |                 |              |
3563 //     |                 |   SubDelResp |
3564 //     |                 |<-------------|
3565 //     |       RESTNotif |              |
3566 //     |       unsuccess |              |
3567 //     |<----------------|              |
3568 //     |                 |              |
3569 //     |            [SUBS DELETE]       |
3570 //     |                 |              |
3571 //
3572 //-----------------------------------------------------------------------------
3573 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
3574         CaseBegin("TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr start")
3575
3576         // Init counter check
3577         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3578                 Counter{cRestSubReqFromXapp, 1},
3579                 Counter{cRestSubRespToXapp, 1},
3580                 Counter{cSubReqToE2, 1},
3581                 Counter{cSubReReqToE2, 1},
3582                 Counter{cSubReqTimerExpiry, 2},
3583                 Counter{cSubDelReqToE2, 1},
3584                 Counter{cSubDelReReqToE2, 1},
3585                 Counter{cSubDelReqTimerExpiry, 2},
3586         })
3587
3588         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3589         restSubId := xappConn1.SendRESTSubsReq(t, params)
3590         xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
3591
3592         e2termConn1.RecvSubsReq(t)
3593         xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3594
3595         e2termConn1.RecvSubsReq(t)
3596         xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3597
3598         e2termConn1.RecvSubsDelReq(t)
3599         xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3600
3601         xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3602         e2termConn1.RecvSubsDelReq(t)
3603         xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3604
3605         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3606
3607         waitSubsCleanup(t, e2SubsId, 10)
3608
3609         mainCtrl.VerifyCounterValues(t)
3610 }
3611
3612 //-----------------------------------------------------------------------------
3613 // TestRESTSubReqSubFailRespInSubmgr
3614 //
3615 //   stub                             stub
3616 // +-------+        +---------+    +---------+
3617 // | xapp  |        | submgr  |    | e2term  |
3618 // +-------+        +---------+    +---------+
3619 //     |                 |              |
3620 //     | RESTSubReq      |              |
3621 //     |---------------->|              |
3622 //     |                 |              |
3623 //     |     RESTSubResp |              |
3624 //     |<----------------|              |
3625 //     |                 | SubReq       |
3626 //     |                 |------------->|
3627 //     |                 |              |
3628 //     |                 |      SubFail |
3629 //     |                 |<-------------|
3630 //     |                 |              |
3631 //     |                 | SubDelReq    |
3632 //     |                 |------------->|
3633 //     |                 |              |
3634 //     |                 |   SubDelResp |
3635 //     |                 |<-------------|
3636 //     |                 |              |
3637 //     |       RESTNotif |              |
3638 //     |       unsuccess |              |
3639 //     |<----------------|              |
3640 //     |                 |              |
3641 //     |            [SUBS DELETE]       |
3642 //     |                 |              |
3643 //
3644 //-----------------------------------------------------------------------------
3645 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
3646         CaseBegin("TestRESTSubReqSubFailRespInSubmgr")
3647
3648         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3649                 Counter{cRestSubReqFromXapp, 1},
3650                 Counter{cRestSubRespToXapp, 1},
3651                 Counter{cSubReqToE2, 1},
3652                 Counter{cSubFailFromE2, 1},
3653                 Counter{cRestSubFailNotifToXapp, 1},
3654                 Counter{cRestSubDelReqFromXapp, 1},
3655         })
3656
3657         const subReqCount int = 1
3658
3659         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3660         restSubId := xappConn1.SendRESTSubsReq(t, params)
3661
3662         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3663         fparams1 := &teststube2ap.E2StubSubsFailParams{}
3664         fparams1.Set(crereq1)
3665         e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3666
3667         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3668         xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3669         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3670         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3671         xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
3672
3673         // REST subscription sill there to be deleted
3674         xappConn1.SendRESTSubsDelReq(t, &restSubId)
3675
3676         // Wait that subs is cleaned
3677         waitSubsCleanup(t, e2SubsId, 10)
3678
3679         mainCtrl.VerifyCounterValues(t)
3680
3681 }
3682
3683 //-----------------------------------------------------------------------------
3684 // TestRESTSubDelReqRetryInSubmgr
3685 //
3686 //   stub                             stub
3687 // +-------+        +---------+    +---------+
3688 // | xapp  |        | submgr  |    | e2term  |
3689 // +-------+        +---------+    +---------+
3690 //     |                 |              |
3691 //     |            [SUBS CREATE]       |
3692 //     |                 |              |
3693 //     |                 |              |
3694 //     | RESTSubDelReq   |              |
3695 //     |---------------->|              |
3696 //     |                 |              |
3697 //     |  RESTSubDelResp |              |
3698 //     |<----------------|              |
3699 //     |                 | SubDelReq    |
3700 //     |                 |------------->|
3701 //     |                 |              |
3702 //     |                 | SubDelReq    |
3703 //     |                 |------------->|
3704 //     |                 |              |
3705 //     |                 |   SubDelResp |
3706 //     |                 |<-------------|
3707 //     |                 |              |
3708 //
3709 //-----------------------------------------------------------------------------
3710 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
3711         CaseBegin("TestRESTSubDelReqRetryInSubmgr")
3712
3713         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3714                 Counter{cRestSubReqFromXapp, 1},
3715                 Counter{cRestSubRespToXapp, 1},
3716                 Counter{cSubReqToE2, 1},
3717                 Counter{cSubRespFromE2, 1},
3718                 Counter{cRestSubNotifToXapp, 1},
3719                 Counter{cRestSubDelReqFromXapp, 1},
3720                 Counter{cSubDelReqToE2, 1},
3721                 Counter{cSubDelReReqToE2, 1},
3722                 Counter{cSubDelRespFromE2, 1},
3723                 Counter{cRestSubDelRespToXapp, 1},
3724         })
3725         // Req
3726         var params *teststube2ap.RESTSubsReqParams = nil
3727         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3728
3729         // Del
3730         xappConn1.SendRESTSubsDelReq(t, &restSubId)
3731
3732         // E2t: Receive 1st SubsDelReq
3733         e2termConn1.RecvSubsDelReq(t)
3734
3735         // E2t: Receive 2nd SubsDelReq and send SubsDelResp
3736         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3737         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3738
3739         //Wait that subs is cleaned
3740         waitSubsCleanup(t, e2SubsId, 10)
3741
3742         mainCtrl.VerifyCounterValues(t)
3743 }
3744
3745 //-----------------------------------------------------------------------------
3746 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
3747 //
3748 //   stub                             stub
3749 // +-------+        +---------+    +---------+
3750 // | xapp  |        | submgr  |    | e2term  |
3751 // +-------+        +---------+    +---------+
3752 //     |                 |              |
3753 //     |            [SUBS CREATE]       |
3754 //     |                 |              |
3755 //     |                 |              |
3756 //     | RESTSubDelReq   |              |
3757 //     |---------------->|              |
3758 //     |                 |              |
3759 //     |  RESTSubDelResp |              |
3760 //     |<----------------|              |
3761 //     |                 | SubDelReq    |
3762 //     |                 |------------->|
3763 //     |                 |              |
3764 //     |                 | SubDelReq    |
3765 //     |                 |------------->|
3766 //     |                 |              |
3767 //     |                 |              |
3768 //
3769 //-----------------------------------------------------------------------------
3770 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
3771         CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr")
3772
3773         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3774                 Counter{cRestSubReqFromXapp, 1},
3775                 Counter{cRestSubRespToXapp, 1},
3776                 Counter{cSubReqToE2, 1},
3777                 Counter{cSubRespFromE2, 1},
3778                 Counter{cRestSubNotifToXapp, 1},
3779                 Counter{cRestSubDelReqFromXapp, 1},
3780                 Counter{cSubDelReqToE2, 1},
3781                 Counter{cSubDelReReqToE2, 1},
3782                 Counter{cSubDelRespFromE2, 1},
3783                 Counter{cRestSubDelRespToXapp, 1},
3784         })
3785
3786         // Req
3787         var params *teststube2ap.RESTSubsReqParams = nil
3788         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3789
3790         // Del
3791         xappConn1.SendRESTSubsDelReq(t, &restSubId)
3792
3793         // E2t: Receive 1st SubsDelReq
3794         e2termConn1.RecvSubsDelReq(t)
3795
3796         // E2t: Receive 2nd SubsDelReq and send SubsDelResp
3797         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3798         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3799
3800         //Wait that subs is cleaned
3801         waitSubsCleanup(t, e2SubsId, 10)
3802
3803         mainCtrl.VerifyCounterValues(t)
3804 }
3805
3806 //-----------------------------------------------------------------------------
3807 // TestRESTSubDelReqSubDelFailRespInSubmgr
3808 //
3809 //   stub                             stub
3810 // +-------+        +---------+    +---------+
3811 // | xapp  |        | submgr  |    | e2term  |
3812 // +-------+        +---------+    +---------+
3813 //     |                 |              |
3814 //     |            [SUBS CREATE]       |
3815 //     |                 |              |
3816 //     |                 |              |
3817 //     | RESTSubDelReq   |              |
3818 //     |---------------->|              |
3819 //     |                 |              |
3820 //     |  RESTSubDelResp |              |
3821 //     |<----------------|              |
3822 //     |                 | SubDelReq    |
3823 //     |                 |------------->|
3824 //     |                 |              |
3825 //     |                 |   SubDelFail |
3826 //     |                 |<-------------|
3827 //     |                 |              |
3828 //
3829 //-----------------------------------------------------------------------------
3830 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
3831         CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr")
3832
3833         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3834                 Counter{cRestSubReqFromXapp, 1},
3835                 Counter{cRestSubRespToXapp, 1},
3836                 Counter{cSubReqToE2, 1},
3837                 Counter{cSubRespFromE2, 1},
3838                 Counter{cRestSubNotifToXapp, 1},
3839                 Counter{cRestSubDelReqFromXapp, 1},
3840                 Counter{cSubDelReqToE2, 1},
3841                 Counter{cSubDelFailFromE2, 1},
3842                 Counter{cRestSubDelRespToXapp, 1},
3843         })
3844
3845         // Req
3846         var params *teststube2ap.RESTSubsReqParams = nil
3847         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3848
3849         // Del
3850         xappConn1.SendRESTSubsDelReq(t, &restSubId)
3851
3852         // E2t: Send receive SubsDelReq and send SubsDelFail
3853         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3854         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
3855
3856         //Wait that subs is cleaned
3857         waitSubsCleanup(t, e2SubsId, 10)
3858
3859         mainCtrl.VerifyCounterValues(t)
3860 }
3861
3862 //-----------------------------------------------------------------------------
3863 // TestRESTSubReqAndSubDelOkSameAction
3864 //
3865 //   stub                             stub
3866 // +-------+     +-------+        +---------+    +---------+
3867 // | xapp2 |     | xapp1 |        | submgr  |    | e2term  |
3868 // +-------+     +-------+        +---------+    +---------+
3869 //     |             |                 |              |
3870 //     |             | RESTSubReq1     |              |
3871 //     |             |---------------->|              |
3872 //     |             |                 |              |
3873 //     |             |    RESTSubResp1 |              |
3874 //     |             |<----------------|              |
3875 //     |             |                 |              |
3876 //     |             |                 | SubReq1      |
3877 //     |             |                 |------------->|
3878 //     |             |                 |    SubResp1  |
3879 //     |             |                 |<-------------|
3880 //     |             |      RESTNotif1 |              |
3881 //     |             |<----------------|              |
3882 //     |             |                 |              |
3883 //     | RESTSubReq2                   |              |
3884 //     |------------------------------>|              |
3885 //     |             |                 |              |
3886 //     |                  RESTSubResp2 |              |
3887 //     |<------------------------------|              |
3888 //     |             |                 |              |
3889 //     |             |      RESTNotif2 |              |
3890 //     |<------------------------------|              |
3891 //     |             |                 |              |
3892 //     |             | RESTSubDelReq1  |              |
3893 //     |             |---------------->|              |
3894 //     |             |                 |              |
3895 //     |             | RESTSubDelResp1 |              |
3896 //     |             |<----------------|              |
3897 //     |             |                 |              |
3898 //     | RESTSubDelReq2                |              |
3899 //     |------------------------------>|              |
3900 //     |             |                 |              |
3901 //     |               RESTSubDelResp2 |              |
3902 //     |<------------------------------|              |
3903 //     |             |                 |              |
3904 //     |             |                 | SubDelReq2   |
3905 //     |             |                 |------------->|
3906 //     |             |                 |              |
3907 //     |             |                 |  SubDelResp2 |
3908 //     |             |                 |<-------------|
3909 //     |             |                 |              |
3910 //
3911 //-----------------------------------------------------------------------------
3912 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
3913         CaseBegin("TestRESTSubReqAndSubDelOkSameAction")
3914
3915         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3916                 Counter{cRestSubReqFromXapp, 2},
3917                 Counter{cRestSubRespToXapp, 2},
3918                 Counter{cSubReqToE2, 1},
3919                 Counter{cSubRespFromE2, 1},
3920                 Counter{cRestSubNotifToXapp, 2},
3921                 Counter{cMergedSubscriptions, 1},
3922                 Counter{cUnmergedSubscriptions, 1},
3923                 Counter{cRestSubDelReqFromXapp, 2},
3924                 Counter{cSubDelReqToE2, 1},
3925                 Counter{cSubDelRespFromE2, 1},
3926                 Counter{cRestSubDelRespToXapp, 2},
3927         })
3928
3929         // Req1
3930         var params *teststube2ap.RESTSubsReqParams = nil
3931
3932         //Subs Create
3933         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3934         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
3935
3936         // Req2
3937         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3938         params.SetMeid("RAN_NAME_1")
3939
3940         xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
3941         xappConn2.WaitRESTNotificationForAnySubscriptionId(t)
3942         waiter := rtmgrHttp.AllocNextSleep(10, true)
3943         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3944         waiter.WaitResult(t)
3945         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
3946         e2SubsId2 := <-xappConn2.RESTNotification
3947         xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
3948
3949         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
3950
3951         // Del1
3952         xappConn1.SendRESTSubsDelReq(t, &restSubId1)
3953
3954         // Del2
3955         deleteXapp2Subscription(t, &restSubId2)
3956
3957         //Wait that subs is cleaned
3958         waitSubsCleanup(t, e2SubsId2, 10)
3959
3960         mainCtrl.VerifyCounterValues(t)
3961 }
3962
3963 //-----------------------------------------------------------------------------
3964 // TestSubReqAndSubDelOkSameActionParallel
3965 //
3966 //   stub          stub                          stub
3967 // +-------+     +-------+     +---------+    +---------+
3968 // | xapp2 |     | xapp1 |     | submgr  |    | e2term  |
3969 // +-------+     +-------+     +---------+    +---------+
3970 //     |             |              |              |
3971 //     |             |              |              |
3972 //     |             |              |              |
3973 //     |             | SubReq1      |              |
3974 //     |             |------------->|              |
3975 //     |             |              |              |
3976 //     |             |              | SubReq1      |
3977 //     |             |              |------------->|
3978 //     |          SubReq2           |              |
3979 //     |--------------------------->|              |
3980 //     |             |              |    SubResp1  |
3981 //     |             |              |<-------------|
3982 //     |             |    SubResp1  |              |
3983 //     |             |<-------------|              |
3984 //     |             |              | SubReq2      |
3985 //     |             |              |------------->|
3986 //     |             |              |              |
3987 //     |             |              |    SubResp2  |
3988 //     |             |              |<-------------|
3989 //     |          SubResp2          |              |
3990 //     |<---------------------------|              |
3991 //     |             |              |              |
3992 //     |             | SubDelReq 1  |              |
3993 //     |             |------------->|              |
3994 //     |             |              |              |
3995 //     |             | SubDelResp 1 |              |
3996 //     |             |<-------------|              |
3997 //     |             |              |              |
3998 //     |         SubDelReq 2        |              |
3999 //     |--------------------------->|              |
4000 //     |             |              |              |
4001 //     |             |              | SubDelReq 2  |
4002 //     |             |              |------------->|
4003 //     |             |              |              |
4004 //     |             |              | SubDelReq 2  |
4005 //     |             |              |------------->|
4006 //     |             |              |              |
4007 //     |         SubDelResp 2       |              |
4008 //     |<---------------------------|              |
4009 //
4010 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
4011         CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel")
4012
4013         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4014                 Counter{cRestSubReqFromXapp, 2},
4015                 Counter{cRestSubRespToXapp, 2},
4016                 Counter{cSubReqToE2, 2},
4017                 Counter{cSubRespFromE2, 2},
4018                 Counter{cRestSubNotifToXapp, 2},
4019                 Counter{cRestSubDelReqFromXapp, 2},
4020                 Counter{cSubDelReqToE2, 2},
4021                 Counter{cSubDelRespFromE2, 2},
4022                 Counter{cRestSubDelRespToXapp, 2},
4023         })
4024
4025         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4026         restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4027         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4028
4029         params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4030         restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4031
4032         xappConn1.ExpectRESTNotification(t, restSubId1)
4033         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4034         e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4035
4036         xappConn2.ExpectRESTNotification(t, restSubId2)
4037         crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
4038         e2termConn1.SendSubsResp(t, crereq2, cremsg2)
4039         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4040
4041         // Del1
4042         xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4043         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4044         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4045         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4046
4047         // Del2
4048         xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4049         delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
4050         e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
4051
4052         waitSubsCleanup(t, e2SubsId2, 10)
4053
4054         mainCtrl.VerifyCounterValues(t)
4055 }
4056
4057 //-----------------------------------------------------------------------------
4058 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
4059 //
4060 //   stub          stub                             stub
4061 // +-------+     +-------+        +---------+    +---------+
4062 // | xapp2 |     | xapp1 |        | submgr  |    | e2term  |
4063 // +-------+     +-------+        +---------+    +---------+
4064 //     |             |                 |              |
4065 //     |             |                 |              |
4066 //     |             |                 |              |
4067 //     |             | RESTSubReq1     |              |
4068 //     |             |---------------->|              |
4069 //     |             |                 |              |
4070 //     |             |    RESTSubResp1 |              |
4071 //     |             |<----------------|              |
4072 //     |             |                 | SubReq1      |
4073 //     |             |                 |------------->|
4074 //     | RESTSubReq2                   |              |
4075 //     |------------------------------>|              |
4076 //     |             |                 |              |
4077 //     |               RESTSubDelResp2 |              |
4078 //     |<------------------------------|              |
4079 //     |             |                 | SubReq1      |
4080 //     |             |                 |------------->|
4081 //     |             |                 |              |
4082 //     |             |                 |              |
4083 //     |             |                 | SubDelReq    |
4084 //     |             |                 |------------->|
4085 //     |             |                 |              |
4086 //     |             |                 |   SubDelResp |
4087 //     |             |                 |<-------------|
4088 //     |             |      RESTNotif1 |              |
4089 //     |             |       unsuccess |              |
4090 //     |             |<----------------|              |
4091 //     |                    RESTNotif2 |              |
4092 //     |             |       unsuccess |              |
4093 //     |<------------------------------|              |
4094 //     |             |                 |              |
4095 //     |             | RESTSubDelReq1  |              |
4096 //     |             |---------------->|              |
4097 //     |             |                 |              |
4098 //     |             | RESTSubDelResp1 |              |
4099 //     |             |<----------------|              |
4100 //     |             |                 |              |
4101 //     | RESTSubDelReq2                |              |
4102 //     |------------------------------>|              |
4103 //     |             |                 |              |
4104 //     |               RESTSubDelResp2 |              |
4105 //     |<------------------------------|              |
4106 //
4107 //-----------------------------------------------------------------------------
4108 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
4109         CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
4110
4111         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4112                 Counter{cRestSubReqFromXapp, 2},
4113                 Counter{cRestSubRespToXapp, 2},
4114                 Counter{cSubReqToE2, 1},
4115                 Counter{cRestSubFailNotifToXapp, 2},
4116                 Counter{cRestSubDelReqFromXapp, 2},
4117                 Counter{cSubDelReqToE2, 1},
4118                 Counter{cSubDelRespFromE2, 1},
4119                 Counter{cRestSubDelRespToXapp, 2},
4120         })
4121
4122         const subReqCount int = 1
4123
4124         // Req1
4125         params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4126         restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
4127         crereq1, _ := e2termConn1.RecvSubsReq(t)
4128
4129         // Req2
4130         subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4131         params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4132         params2.SetMeid("RAN_NAME_1")
4133         restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4134         mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4135
4136         //Req1 (retransmitted)
4137         e2termConn1.RecvSubsReq(t)
4138
4139         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4140
4141         xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4142         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4143
4144         e2SubsIdA := <-xappConn1.ListedRESTNotifications
4145         xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4146         e2SubsIdB := <-xappConn1.ListedRESTNotifications
4147         xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4148
4149         // Del1
4150         xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4151
4152         // Del2
4153         xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4154
4155         mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
4156
4157         //Wait that subs is cleaned
4158         waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4159
4160         mainCtrl.VerifyCounterValues(t)
4161 }
4162
4163 //-----------------------------------------------------------------------------
4164 // TestRESTSubReqAndSubDelNokSameActionParallel
4165 //
4166 //   stub          stub                             stub
4167 // +-------+     +-------+        +---------+    +---------+
4168 // | xapp2 |     | xapp1 |        | submgr  |    | e2term  |
4169 // +-------+     +-------+        +---------+    +---------+
4170 //     |             |                 |              |
4171 //     |             |                 |              |
4172 //     |             |                 |              |
4173 //     |             | RESTSubReq1     |              |
4174 //     |             |---------------->|              |
4175 //     |             |                 |              |
4176 //     |             |    RESTSubResp1 |              |
4177 //     |             |<----------------|              |
4178 //     |             |                 | SubReq1      |
4179 //     |             |                 |------------->|
4180 //     | RESTSubReq2                   |              |
4181 //     |------------------------------>|              |
4182 //     |             |                 |              |
4183 //     |               RESTSubDelResp2 |              |
4184 //     |<------------------------------|              |
4185 //     |             |                 |    SubFail1  |
4186 //     |             |                 |<-------------|
4187 //     |             |                 |              |
4188 //     |             |      RESTNotif1 |              |
4189 //     |             |       unsuccess |              |
4190 //     |             |<----------------|              |
4191 //     |                    RESTNotif2 |              |
4192 //     |             |       unsuccess |              |
4193 //     |<------------------------------|              |
4194 //     |             |                 | SubDelReq    |
4195 //     |             |                 |------------->|
4196 //     |             |                 |   SubDelResp |
4197 //     |             |                 |<-------------|
4198 //     |             |                 |              |
4199 //     |             | RESTSubDelReq1  |              |
4200 //     |             |---------------->|              |
4201 //     |             |                 |              |
4202 //     |             | RESTSubDelResp1 |              |
4203 //     |             |<----------------|              |
4204 //     |             |                 |              |
4205 //     | RESTSubDelReq2                |              |
4206 //     |------------------------------>|              |
4207 //     |             |                 |              |
4208 //     |               RESTSubDelResp2 |              |
4209 //     |<------------------------------|              |
4210 //
4211 //-----------------------------------------------------------------------------
4212 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
4213         CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
4214
4215         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4216                 Counter{cRestSubReqFromXapp, 2},
4217                 Counter{cRestSubRespToXapp, 2},
4218                 Counter{cSubReqToE2, 1},
4219                 Counter{cSubFailFromE2, 1},
4220                 Counter{cRestSubFailNotifToXapp, 2},
4221                 Counter{cRestSubDelReqFromXapp, 2},
4222                 Counter{cSubDelReqToE2, 1},
4223                 Counter{cSubDelRespFromE2, 1},
4224                 Counter{cRestSubDelRespToXapp, 2},
4225         })
4226
4227         const subReqCount int = 1
4228
4229         // Req1
4230         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4231         restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4232         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4233
4234         // Req2
4235         subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4236         params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4237         params2.SetMeid("RAN_NAME_1")
4238         restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4239         mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4240
4241         // E2t: send SubsFail (first)
4242         fparams1 := &teststube2ap.E2StubSubsFailParams{}
4243         fparams1.Set(crereq1)
4244         e2termConn1.SendSubsFail(t, fparams1, cremsg1)
4245
4246         // E2t: internal delete
4247         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4248         xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4249         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4250
4251         e2SubsIdA := <-xappConn1.ListedRESTNotifications
4252         xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4253         e2SubsIdB := <-xappConn1.ListedRESTNotifications
4254         xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4255
4256         // Del1
4257         xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4258
4259         // Del2
4260         xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4261
4262         //Wait that subs is cleaned
4263         waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4264         waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
4265
4266         mainCtrl.VerifyCounterValues(t)
4267 }
4268
4269 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
4270         CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4271
4272         // Init counter check
4273         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4274                 Counter{cRestSubReqFromXapp, 1},
4275                 Counter{cRestSubRespToXapp, 1},
4276                 Counter{cSubReqToE2, 1},
4277                 Counter{cSubRespFromE2, 1},
4278                 Counter{cRestSubNotifToXapp, 1},
4279                 Counter{cRestSubDelReqFromXapp, 1},
4280                 Counter{cSubDelReqToE2, 1},
4281                 Counter{cSubDelRespFromE2, 1},
4282                 Counter{cRestSubDelRespToXapp, 1},
4283         })
4284
4285         const subReqCount int = 1
4286
4287         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4288         restSubId := xappConn1.SendRESTSubsReq(t, params)
4289         xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
4290
4291         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4292         xappConn1.ExpectRESTNotification(t, restSubId)
4293         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4294         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4295         xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
4296
4297         xappConn1.SendRESTSubsDelReq(t, &restSubId)
4298         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4299         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4300
4301         // Wait that subs is cleaned
4302         waitSubsCleanup(t, e2SubsId, 10)
4303         mainCtrl.VerifyCounterValues(t)
4304 }
4305
4306 //-----------------------------------------------------------------------------
4307 // TestRESTSubReqPolicyChangeAndSubDelOk
4308 //
4309 //   stub                             stub
4310 // +-------+        +---------+    +---------+
4311 // | xapp  |        | submgr  |    | e2term  |
4312 // +-------+        +---------+    +---------+
4313 //     |                 |              |
4314 //     | RESTSubReq      |              |
4315 //     |---------------->|              |
4316 //     |                 |              |
4317 //     |     RESTSubResp |              |
4318 //     |<----------------|              |
4319 //     |                 | SubReq       |
4320 //     |                 |------------->|
4321 //     |                 |              |
4322 //     |                 |      SubResp |
4323 //     |                 |<-------------|
4324 //     |                 |              |
4325 //     |       RESTNotif |              |
4326 //     |<----------------|              |
4327 //     |                 |              |
4328 //     | RESTSubReq      |              |
4329 //     |---------------->|              |
4330 //     |                 |              |
4331 //     |     RESTSubResp |              |
4332 //     |<----------------|              |
4333 //     |                 | SubReq       |
4334 //     |                 |------------->|
4335 //     |                 |              |
4336 //     |                 |      SubResp |
4337 //     |                 |<-------------|
4338 //     |                 |              |
4339 //     |       RESTNotif |              |
4340 //     |<----------------|              |
4341 //     |                 |              |
4342 //     | RESTSubDelReq   |              |
4343 //     |---------------->|              |
4344 //     |                 |              |
4345 //     |                 | SubDelReq    |
4346 //     |                 |------------->|
4347 //     |                 |              |
4348 //     |                 |   SubDelResp |
4349 //     |                 |<-------------|
4350 //     |                 |              |
4351 //     |  RESTSubDelResp |              |
4352 //     |<----------------|              |
4353 //
4354 //-----------------------------------------------------------------------------
4355 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
4356         CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4357
4358         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4359                 Counter{cRestSubReqFromXapp, 2},
4360                 Counter{cRestSubRespToXapp, 2},
4361                 Counter{cSubReqToE2, 2},
4362                 Counter{cSubRespFromE2, 2},
4363                 Counter{cRestSubNotifToXapp, 2},
4364                 Counter{cRestSubDelReqFromXapp, 1},
4365                 Counter{cSubDelReqToE2, 1},
4366                 Counter{cSubDelRespFromE2, 1},
4367                 Counter{cRestSubDelRespToXapp, 1},
4368         })
4369
4370         const subReqCount int = 1
4371
4372         // Req
4373         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4374         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4375
4376         // Policy change
4377         // GetRESTSubsReqPolicyParams sets some coutners on tc side.
4378
4379         params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4380         params.SetSubscriptionID(&restSubId)
4381         params.SetTimeToWait("w200ms")
4382         restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
4383
4384         // Del
4385         xappConn1.SendRESTSubsDelReq(t, &restSubId)
4386
4387         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4388         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4389
4390         // Wait that subs is cleaned
4391         waitSubsCleanup(t, e2SubsId, 10)
4392         mainCtrl.VerifyCounterValues(t)
4393 }
4394
4395 //-----------------------------------------------------------------------------
4396 // TestRESTSubReqPolicyChangeNOk
4397 //
4398 //   stub                             stub
4399 // +-------+        +---------+    +---------+
4400 // | xapp  |        | submgr  |    | e2term  |
4401 // +-------+        +---------+    +---------+
4402 //     |                 |              |
4403 //     | RESTSubReq      |              |
4404 //     |---------------->|              |
4405 //     |                 |              |
4406 //     |     RESTSubResp |              |
4407 //     |<----------------|              |
4408 //     |                 | SubReq       |
4409 //     |                 |------------->|
4410 //     |                 |              |
4411 //     |                 |      SubResp |
4412 //     |                 |<-------------|
4413 //     |                 |              |
4414 //     |       RESTNotif |              |
4415 //     |<----------------|              |
4416 //     |                 |              |
4417 //     | RESTSubReq      |              |
4418 //     |---------------->|              |
4419 //     |                 |              |
4420 //     |         RESTSubUpdateFail      |
4421 //     |                 |              |
4422 //     | RESTSubDelReq   |              |
4423 //     |---------------->|              |
4424 //     |                 |              |
4425 //     |                 | SubDelReq    |
4426 //     |                 |------------->|
4427 //     |                 |              |
4428 //     |                 |   SubDelResp |
4429 //     |                 |<-------------|
4430 //     |                 |              |
4431 //     |  RESTSubDelResp |              |
4432 //     |<----------------|              |
4433 //
4434 //-----------------------------------------------------------------------------
4435 func TestRESTSubReqPolicyChangeNOk(t *testing.T) {
4436         CaseBegin("TestRESTSubReqPolicyChangeNOk")
4437
4438         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4439                 Counter{cRestSubReqFromXapp, 2},
4440                 Counter{cRestSubRespToXapp, 1},
4441                 Counter{cSubReqToE2, 1},
4442                 Counter{cSubRespFromE2, 1},
4443                 Counter{cRestSubNotifToXapp, 1},
4444                 Counter{cRestSubFailToXapp, 1},
4445                 Counter{cRestSubDelReqFromXapp, 1},
4446                 Counter{cSubDelReqToE2, 1},
4447                 Counter{cSubDelRespFromE2, 1},
4448                 Counter{cRestSubDelRespToXapp, 1},
4449         })
4450
4451         const subReqCount int = 1
4452
4453         // Req
4454         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4455         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4456
4457         // Policy change
4458
4459         params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4460
4461         restSubIdUpd := strings.ToUpper(restSubId)
4462         params.SetSubscriptionID(&restSubIdUpd)
4463         params.SetTimeToWait("w200ms")
4464
4465         restSubId2 := xappConn1.SendRESTSubsReq(t, params)
4466         assert.Equal(t, restSubId2, "")
4467
4468         // Del
4469         xappConn1.SendRESTSubsDelReq(t, &restSubId)
4470
4471         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4472         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4473
4474         // Wait that subs is cleaned
4475         waitSubsCleanup(t, e2SubsId, 10)
4476         mainCtrl.VerifyCounterValues(t)
4477 }
4478
4479 //-----------------------------------------------------------------------------
4480 // TestRESTSubReqAndSubDelOkTwoE2termParallel
4481 //
4482 //   stub                             stub           stub
4483 // +-------+        +---------+    +---------+    +---------+
4484 // | xapp  |        | submgr  |    | e2term1 |    | e2term2 |
4485 // +-------+        +---------+    +---------+    +---------+
4486 //     |                 |              |              |
4487 //     |                 |              |              |
4488 //     |                 |              |              |
4489 //     | RESTSubReq1     |              |              |
4490 //     |---------------->|              |              |
4491 //     |                 |              |              |
4492 //     |    RESTSubResp1 |              |              |
4493 //     |<----------------|              |              |
4494 //     |                 | SubReq1      |              |
4495 //     |                 |------------->|              |
4496 //     |                 |              |              |
4497 //     | RESTSubReq2     |              |              |
4498 //     |---------------->|              |              |
4499 //     |                 |              |              |
4500 //     |    RESTSubResp2 |              |              |
4501 //     |<----------------|              |              |
4502 //     |                 | SubReq2      |              |
4503 //     |                 |---------------------------->|
4504 //     |                 |              |              |
4505 //     |                 |    SubResp1  |              |
4506 //     |                 |<-------------|              |
4507 //     |      RESTNotif1 |              |              |
4508 //     |<----------------|              |              |
4509 //     |                 |    SubResp2  |              |
4510 //     |                 |<----------------------------|
4511 //     |      RESTNotif2 |              |              |
4512 //     |<----------------|              |              |
4513 //     |                 |              |              |
4514 //     |           [SUBS 1 DELETE]      |              |
4515 //     |                 |              |              |
4516 //     |           [SUBS 2 DELETE]      |              |
4517 //     |                 |              |              |
4518 //
4519 //-----------------------------------------------------------------------------
4520 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
4521         CaseBegin("TestRESTSubReqAndSubDelOkTwoE2termParallel")
4522
4523         // Init counter check
4524         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4525                 Counter{cRestSubReqFromXapp, 2},
4526                 Counter{cRestSubRespToXapp, 2},
4527                 Counter{cSubReqToE2, 2},
4528                 Counter{cSubRespFromE2, 2},
4529                 Counter{cRestSubNotifToXapp, 2},
4530                 Counter{cRestSubDelReqFromXapp, 2},
4531                 Counter{cSubDelReqToE2, 2},
4532                 Counter{cSubDelRespFromE2, 2},
4533                 Counter{cRestSubDelRespToXapp, 2},
4534         })
4535
4536         const subReqCount int = 1
4537
4538         // Req1
4539         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4540         restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4541         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4542
4543         // Req2
4544         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4545         params.SetMeid("RAN_NAME_11")
4546         // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
4547         // would not work as notification would not be received
4548         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4549         crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
4550
4551         // Resp1
4552         xappConn1.ExpectRESTNotification(t, restSubId1)
4553         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4554         e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4555         xapp.Logger.Info("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
4556
4557         // Resp2
4558         xappConn2.ExpectRESTNotification(t, restSubId2)
4559         e2termConn2.SendSubsResp(t, crereq2, cremsg2)
4560         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4561         xapp.Logger.Info("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
4562
4563         // Delete1
4564         xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4565         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4566         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4567
4568         // Wait that subs is cleaned
4569         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4570
4571         // Delete2
4572         xappConn1.SendRESTSubsDelReq(t, &restSubId2)
4573         delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
4574         e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
4575
4576         // Wait that subs is cleaned
4577         waitSubsCleanup(t, e2SubsId2, 10)
4578
4579         mainCtrl.VerifyCounterValues(t)
4580 }
4581
4582 //-----------------------------------------------------------------------------
4583 // TestRESTSubReqAsn1EncodeFail
4584 //
4585 // In this case submgr send RICSubscriptionDeleteRequest after encode failure which should not happen!
4586 //   stub                             stub
4587 // +-------+        +---------+    +---------+
4588 // | xapp  |        | submgr  |    | e2term  |
4589 // +-------+        +---------+    +---------+
4590 //     |                 |              |
4591 //     | RESTSubReq      |              |
4592 //     |---------------->|              |
4593 //     |                 |              |
4594 //     |     RESTSubResp |              |
4595 //     |<----------------|              |
4596 //     | RESTSubDelReq   |              |
4597 //     |---------------->|              |
4598 //     |  RESTSubDelResp |              |
4599 //     |     unsuccess   |              |
4600 //     |<----------------|              |
4601 //     |                 |              |
4602 //
4603 //-----------------------------------------------------------------------------
4604 func TestRESTSubReqAsn1EncodeFail(t *testing.T) {
4605         CaseBegin("TestRESTSubReqAsn1EncodeFail")
4606
4607         xapp.Logger.Info("Xapp-frame, v0.8.1 sufficient REST API validation")
4608
4609 }
4610
4611 //-----------------------------------------------------------------------------
4612 // TestRESTSubReqInsertAndSubDelOk
4613 //
4614 //   stub                             stub
4615 // +-------+        +---------+    +---------+
4616 // | xapp  |        | submgr  |    | e2term  |
4617 // +-------+        +---------+    +---------+
4618 //     |                 |              |
4619 //     | RestSubReq      |              |
4620 //     |---------------->|              |
4621 //     |                 |              |
4622 //     |     RESTSubResp |              |
4623 //     |<----------------|              |
4624 //     |                 |              |
4625 //     |                 | SubReq       |
4626 //     |                 |------------->|
4627 //     |                 |              |
4628 //     |                 |      SubResp |
4629 //     |                 |<-------------|
4630 //     | RESTNotif       |              |
4631 //     |<----------------|              |
4632 //     |       ...       |     ...      |
4633 //     |                 |              |
4634 //     | RESTSubDelReq   |              |
4635 //     |---------------->|              |
4636 //     |                 |              |
4637 //     |                 | SubDelReq    |
4638 //     |                 |------------->|
4639 //     |                 |              |
4640 //     |                 |   SubDelResp |
4641 //     |                 |<-------------|
4642 //     |                 |              |
4643 //     |   RESTSubDelResp|              |
4644 //     |<----------------|              |
4645 //
4646 //-----------------------------------------------------------------------------
4647 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
4648         CaseBegin("TestRESTInsertSubReqAndSubDelOk")
4649
4650         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4651                 Counter{cRestSubReqFromXapp, 1},
4652                 Counter{cRestSubRespToXapp, 1},
4653                 Counter{cSubReqToE2, 1},
4654                 Counter{cSubRespFromE2, 1},
4655                 Counter{cRestSubNotifToXapp, 1},
4656                 Counter{cRestSubDelReqFromXapp, 1},
4657                 Counter{cSubDelReqToE2, 1},
4658                 Counter{cSubDelRespFromE2, 1},
4659                 Counter{cRestSubDelRespToXapp, 1},
4660         })
4661
4662         const subReqCount int = 1
4663
4664         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4665         params.SetSubActionTypes("insert")
4666
4667         // Req
4668         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4669
4670         // Del
4671         xappConn1.SendRESTSubsDelReq(t, &restSubId)
4672
4673         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4674         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4675
4676         // Wait that subs is cleaned
4677         waitSubsCleanup(t, e2SubsId, 10)
4678         mainCtrl.VerifyCounterValues(t)
4679 }
4680
4681 //-----------------------------------------------------------------------------
4682 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
4683 //
4684 //   stub                          stub
4685 // +-------+     +---------+    +---------+
4686 // | xapp  |     | submgr  |    | e2term  |
4687 // +-------+     +---------+    +---------+
4688 //     |              |              |
4689 //     | RESTSubReq   |              |
4690 //     |------------->|              |
4691 //     |              |              |
4692 //     |              | SubReq       |
4693 //     |              |------------->|
4694 //     |              |              |
4695 //     |              |      SubResp |
4696 //     |                        <----|
4697 //     |                             |
4698 //     |        Submgr restart       |
4699 //     |                             |
4700 //     |              |              |
4701 //     |              | SubDelReq    |
4702 //     |              |------------->|
4703 //     |              |              |
4704 //     |              |   SubDelResp |
4705 //     |              |<-------------|
4706 //     |              |              |
4707 //
4708 //-----------------------------------------------------------------------------
4709 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
4710         CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle")
4711
4712         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4713                 Counter{cRestSubReqFromXapp, 1},
4714                 Counter{cRestSubRespToXapp, 1},
4715                 Counter{cSubReqToE2, 1},
4716                 Counter{cSubDelReqFromXapp, 1},
4717                 Counter{cSubDelReqToE2, 1},
4718                 Counter{cSubDelRespFromE2, 1},
4719         })
4720
4721         const subReqCount int = 1
4722
4723         // Remove possible existing subscription
4724         mainCtrl.removeExistingSubscriptions(t)
4725
4726         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4727
4728         //Req
4729         mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
4730         restSubId := xappConn1.SendRESTSubsReq(t, params)
4731         xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
4732
4733         e2termConn1.RecvSubsReq(t)
4734
4735         mainCtrl.SetResetTestFlag(t, false)
4736
4737         mainCtrl.SimulateRestart(t)
4738         xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4739
4740         //Del
4741         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4742         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4743
4744         xappConn1.TestMsgChanEmpty(t)
4745         xappConn2.TestMsgChanEmpty(t)
4746         e2termConn1.TestMsgChanEmpty(t)
4747         mainCtrl.wait_registry_empty(t, 10)
4748
4749         mainCtrl.VerifyCounterValues(t)
4750 }
4751
4752 //-----------------------------------------------------------------------------
4753 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
4754 //
4755 //   stub                             stub
4756 // +-------+        +---------+    +---------+
4757 // | xapp  |        | submgr  |    | e2term  |
4758 // +-------+        +---------+    +---------+
4759 //     |                 |              |
4760 //     | RESTSubReq      |              |
4761 //     |---------------->|              |
4762 //     |                 |              |
4763 //     |     RESTSubResp |              |
4764 //     |<----------------|              |
4765 //     |                 | SubReq       |
4766 //     |                 |------------->|
4767 //     |                 |              |
4768 //     |                 |      SubResp |
4769 //     |                 |<-------------|
4770 //     |                 |              |
4771 //     |       RESTNotif |              |
4772 //     |<----------------|              |
4773 //     |                 |              |
4774 //     |                                |
4775 //     |           Submgr restart       |
4776 //     |                 |              |
4777 //     | RESTSubDelReq   |              |
4778 //     |---------------->|              |
4779 //     |                 |              |
4780 //     |                 | SubDelReq    |
4781 //     |                 |------------->|
4782 //     |                 |              |
4783 //     |                 |   SubDelResp |
4784 //     |                 |<-------------|
4785 //     |                 |              |
4786 //     |  RESTSubDelResp |              |
4787 //     |<----------------|              |
4788 //
4789 //-----------------------------------------------------------------------------
4790
4791 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
4792         CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle")
4793
4794         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4795                 Counter{cRestSubReqFromXapp, 1},
4796                 Counter{cRestSubRespToXapp, 1},
4797                 Counter{cSubReqToE2, 1},
4798                 Counter{cSubRespFromE2, 1},
4799                 Counter{cRestSubNotifToXapp, 1},
4800                 Counter{cRestSubDelReqFromXapp, 1},
4801                 Counter{cSubDelReqToE2, 1},
4802                 Counter{cRestSubDelRespToXapp, 1},
4803         })
4804
4805         // Remove possible existing subscription
4806         mainCtrl.removeExistingSubscriptions(t)
4807
4808         var params *teststube2ap.RESTSubsReqParams = nil
4809
4810         // Create subscription
4811         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4812         xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
4813
4814         // Check subscription
4815         queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4816
4817         // When SDL support for the REST Interface is added
4818         // the submgr restart statement below should be removed
4819         // from the comment.
4820
4821         //      mainCtrl.SimulateRestart(t)
4822         //      xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4823
4824         // Check subscription
4825         queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4826
4827         // Delete subscription
4828         deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
4829
4830         //Wait that subs is cleaned
4831         waitSubsCleanup(t, e2SubsId, 10)
4832
4833         mainCtrl.VerifyCounterValues(t)
4834 }
4835
4836 //-----------------------------------------------------------------------------
4837 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
4838 //
4839 //   stub                             stub
4840 // +-------+     +-------+        +---------+    +---------+
4841 // | xapp2 |     | xapp1 |        | submgr  |    | e2term  |
4842 // +-------+     +-------+        +---------+    +---------+
4843 //     |             |                 |              |
4844 //     |             | RESTSubReq1     |              |
4845 //     |             |---------------->|              |
4846 //     |             |                 |              |
4847 //     |             |    RESTSubResp1 |              |
4848 //     |             |<----------------|              |
4849 //     |             |                 |              |
4850 //     |             |                 | SubReq1      |
4851 //     |             |                 |------------->|
4852 //     |             |                 |    SubResp1  |
4853 //     |             |                 |<-------------|
4854 //     |             |      RESTNotif1 |              |
4855 //     |             |<----------------|              |
4856 //     |             |                 |              |
4857 //     | RESTSubReq2                   |              |
4858 //     |------------------------------>|              |
4859 //     |             |                 |              |
4860 //     |                  RESTSubResp2 |              |
4861 //     |<------------------------------|              |
4862 //     |             |                 |              |
4863 //     |             |      RESTNotif2 |              |
4864 //     |<------------------------------|              |
4865 //     |             |                 |              |
4866 //     |             |           Submgr restart       |
4867 //     |             |                 |              |
4868 //     |             | RESTSubDelReq1  |              |
4869 //     |             |---------------->|              |
4870 //     |             |                 |              |
4871 //     |             | RESTSubDelResp1 |              |
4872 //     |             |<----------------|              |
4873 //     |             |                 |              |
4874 //     |             |           Submgr restart       |
4875 //     |             |                 |              |
4876 //     | RESTSubDelReq2                |              |
4877 //     |------------------------------>|              |
4878 //     |             |                 |              |
4879 //     |               RESTSubDelResp2 |              |
4880 //     |<------------------------------|              |
4881 //     |             |                 |              |
4882 //     |             |                 | SubDelReq2   |
4883 //     |             |                 |------------->|
4884 //     |             |                 |              |
4885 //     |             |                 |  SubDelResp2 |
4886 //     |             |                 |<-------------|
4887 //     |             |                 |              |
4888 //
4889 //-----------------------------------------------------------------------------
4890
4891 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
4892         CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
4893
4894         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4895                 Counter{cRestSubReqFromXapp, 2},
4896                 Counter{cRestSubRespToXapp, 2},
4897                 Counter{cSubReqToE2, 1},
4898                 Counter{cSubRespFromE2, 1},
4899                 Counter{cRestSubNotifToXapp, 2},
4900                 Counter{cMergedSubscriptions, 1},
4901                 Counter{cUnmergedSubscriptions, 1},
4902                 Counter{cRestSubDelReqFromXapp, 2},
4903                 Counter{cSubDelReqToE2, 1},
4904                 Counter{cSubDelRespFromE2, 1},
4905                 Counter{cRestSubDelRespToXapp, 2},
4906         })
4907
4908         // Remove possible existing subscription
4909         mainCtrl.removeExistingSubscriptions(t)
4910
4911         var params *teststube2ap.RESTSubsReqParams = nil
4912
4913         // Create subscription 1
4914         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4915         xapp.Logger.Info("Send REST subscriber request for subscriber 1 : %v", restSubId1)
4916
4917         // Create subscription 2 with same action
4918         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4919         params.SetMeid("RAN_NAME_1")
4920         xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4921         xappConn2.WaitRESTNotificationForAnySubscriptionId(t)
4922         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4923         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
4924         e2SubsId2 := <-xappConn2.RESTNotification
4925         xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
4926
4927         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
4928
4929         // When SDL support for the REST Interface is added
4930         // the submgr restart statement below should be removed
4931         // from the comment.
4932
4933         //      mainCtrl.SimulateRestart(t)
4934         //      xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4935
4936         // Delete subscription 1, and wait until it has removed the first endpoint
4937         subepcnt := mainCtrl.get_subs_entrypoint_cnt(t, e2SubsId1)
4938         xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4939         mainCtrl.wait_subs_entrypoint_cnt_change(t, e2SubsId1, subepcnt, 10)
4940
4941         // When SDL support for the REST Interface is added
4942         // the submgr restart statement below should be removed
4943         // from the comment.
4944
4945         //      mainCtrl.SimulateRestart(t)
4946         //      xapp.Logger.Debug("mainCtrl.SimulateRestart done")
4947         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
4948
4949         // Delete subscription 2
4950         deleteXapp2Subscription(t, &restSubId2)
4951
4952         //Wait that subs is cleaned
4953         waitSubsCleanup(t, e2SubsId2, 10)
4954
4955         mainCtrl.VerifyCounterValues(t)
4956 }
4957
4958 //-----------------------------------------------------------------------------
4959 // TestRESTReportSubReqAndSubDelOk
4960 //
4961 //   stub                             stub
4962 // +-------+        +---------+    +---------+
4963 // | xapp  |        | submgr  |    | e2term  |
4964 // +-------+        +---------+    +---------+
4965 //     |                 |              |
4966 //     | RestSubReq      |              |
4967 //     |---------------->|              |
4968 //     |                 |              |
4969 //     |     RESTSubResp |              |
4970 //     |<----------------|              |
4971 //     |                 |              |
4972 //     |                 | SubReq       |
4973 //     |                 |------------->|
4974 //     |                 |              |
4975 //     |                 |      SubResp |
4976 //     |                 |<-------------|
4977 //     | RESTNotif       |              |
4978 //     |<----------------|              |
4979 //     |                 | SubReq       |
4980 //     |                 |------------->|
4981 //     |                 |              |
4982 //     |                 |      SubResp |
4983 //     |                 |<-------------|
4984 //     | RESTNotif       |              |
4985 //     |<----------------|              |
4986 //     |       ...       |     ...      |
4987 //     |                 |              |
4988 //     |                 |              |
4989 //     | RESTSubDelReq   |              |
4990 //     |---------------->|              |
4991 //     |                 |              |
4992 //     |                 | SubDelReq    |
4993 //     |                 |------------->|
4994 //     |                 |              |
4995 //     |                 |   SubDelResp |
4996 //     |                 |<-------------|
4997 //     |                 |              |
4998 //     |   RESTSubDelResp|              |
4999 //     |<----------------|              |
5000 //
5001 //-----------------------------------------------------------------------------
5002
5003 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
5004         CaseBegin("TestRESTReportSubReqAndSubDelOk")
5005         subReqCount := 1
5006         testIndex := 1
5007         RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
5008 }
5009
5010 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5011         xapp.Logger.Info("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
5012
5013         // Req
5014         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5015         restSubId := xappConn1.SendRESTSubsReq(t, params)
5016
5017         var e2SubsId []uint32
5018         for i := 0; i < subReqCount; i++ {
5019                 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5020                 xappConn1.ExpectRESTNotification(t, restSubId)
5021
5022                 e2termConn1.SendSubsResp(t, crereq, cremsg)
5023                 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5024                 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5025                 e2SubsId = append(e2SubsId, instanceId)
5026                 resp, _ := xapp.Subscription.QuerySubscriptions()
5027                 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
5028                 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
5029                 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
5030
5031         }
5032
5033         // Del
5034         xappConn1.SendRESTSubsDelReq(t, &restSubId)
5035
5036         for i := 0; i < subReqCount; i++ {
5037                 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5038                 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5039         }
5040
5041         // Wait that subs is cleaned
5042         for i := 0; i < subReqCount; i++ {
5043                 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5044         }
5045
5046         xappConn1.TestMsgChanEmpty(t)
5047         e2termConn1.TestMsgChanEmpty(t)
5048         mainCtrl.wait_registry_empty(t, 10)
5049 }
5050
5051 /*
5052 func TestRESTPolicySubReqAndSubDelOk(t *testing.T) {
5053         CaseBegin("TestRESTPolicySubReqAndSubDelOk")
5054
5055         subReqCount := 2
5056         testIndex := 1
5057         RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5058
5059         subReqCount = 19
5060         testIndex = 2
5061         RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5062 }
5063 */
5064 func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5065         xapp.Logger.Info("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
5066
5067         // Req
5068         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5069         restSubId := xappConn1.SendRESTSubsReq(t, params)
5070         //params := xappConn1.GetRESTSubsReqPolicyParams1(subReqCount)
5071         //restSubId := xappConn1.SendRESTPolicySubsReq(t, params)
5072
5073         var e2SubsId []uint32
5074         for i := 0; i < subReqCount; i++ {
5075                 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5076                 xappConn1.ExpectRESTNotification(t, restSubId)
5077                 e2termConn1.SendSubsResp(t, crereq, cremsg)
5078                 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5079                 xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5080                 e2SubsId = append(e2SubsId, instanceId)
5081         }
5082
5083         // Del
5084         xappConn1.SendRESTSubsDelReq(t, &restSubId)
5085
5086         for i := 0; i < subReqCount; i++ {
5087                 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5088                 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5089         }
5090
5091         // Wait that subs is cleaned
5092         for i := 0; i < subReqCount; i++ {
5093                 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5094         }
5095         xappConn1.TestMsgChanEmpty(t)
5096         e2termConn1.TestMsgChanEmpty(t)
5097         mainCtrl.wait_registry_empty(t, 10)
5098 }
5099
5100 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
5101
5102         subReqCount := 2
5103
5104         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5105                 Counter{cRestSubReqFromXapp, 1},
5106                 Counter{cRestSubRespToXapp, 1},
5107                 Counter{cSubReqToE2, 2},
5108                 Counter{cSubRespFromE2, 2},
5109                 Counter{cRestSubNotifToXapp, 2},
5110                 Counter{cRestSubDelReqFromXapp, 1},
5111                 Counter{cSubDelReqToE2, 2},
5112                 Counter{cSubDelRespFromE2, 2},
5113                 Counter{cRestSubDelRespToXapp, 1},
5114         })
5115
5116         // Req
5117         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5118         restSubId := xappConn1.SendRESTSubsReq(t, params)
5119         e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5120
5121         assert.Equal(t, len(e2SubsIds), 2)
5122
5123         // Del
5124         xappConn1.SendRESTSubsDelReq(t, &restSubId)
5125         sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5126
5127         xappConn1.TestMsgChanEmpty(t)
5128         e2termConn1.TestMsgChanEmpty(t)
5129         mainCtrl.wait_registry_empty(t, 10)
5130
5131         mainCtrl.VerifyCounterValues(t)
5132 }
5133 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
5134
5135         subReqCount := 19
5136
5137         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5138                 Counter{cRestSubReqFromXapp, 1},
5139                 Counter{cRestSubRespToXapp, 1},
5140                 Counter{cSubReqToE2, 19},
5141                 Counter{cSubRespFromE2, 19},
5142                 Counter{cRestSubNotifToXapp, 19},
5143                 Counter{cRestSubDelReqFromXapp, 1},
5144                 Counter{cSubDelReqToE2, 19},
5145                 Counter{cSubDelRespFromE2, 19},
5146                 Counter{cRestSubDelRespToXapp, 1},
5147         })
5148
5149         // Req
5150         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5151         restSubId := xappConn1.SendRESTSubsReq(t, params)
5152         e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5153
5154         assert.Equal(t, len(e2SubsIds), 19)
5155
5156         xappConn1.SendRESTSubsDelReq(t, &restSubId)
5157         sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5158
5159         xappConn1.TestMsgChanEmpty(t)
5160         e2termConn1.TestMsgChanEmpty(t)
5161         mainCtrl.wait_registry_empty(t, 10)
5162
5163         mainCtrl.VerifyCounterValues(t)
5164 }
5165 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
5166
5167         subReqCount := 2
5168
5169         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5170                 Counter{cRestSubReqFromXapp, 1},
5171                 Counter{cRestSubRespToXapp, 1},
5172                 Counter{cSubReqToE2, uint64(subReqCount)},
5173                 Counter{cSubRespFromE2, uint64(subReqCount)},
5174                 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5175                 Counter{cRestSubDelReqFromXapp, 1},
5176                 Counter{cSubDelReqToE2, uint64(subReqCount)},
5177                 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5178                 Counter{cRestSubDelRespToXapp, 1},
5179         })
5180
5181         // Req
5182         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5183         restSubId := xappConn1.SendRESTSubsReq(t, params)
5184         e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5185
5186         assert.Equal(t, len(e2SubsIds), subReqCount)
5187
5188         // Del
5189         xappConn1.SendRESTSubsDelReq(t, &restSubId)
5190         sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5191
5192         xappConn1.TestMsgChanEmpty(t)
5193         e2termConn1.TestMsgChanEmpty(t)
5194         mainCtrl.wait_registry_empty(t, 10)
5195
5196         mainCtrl.VerifyCounterValues(t)
5197 }
5198
5199 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
5200
5201         subReqCount := 2
5202
5203         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5204                 Counter{cRestSubReqFromXapp, 1},
5205                 Counter{cRestSubRespToXapp, 1},
5206                 Counter{cSubReqToE2, uint64(subReqCount)},
5207                 Counter{cSubRespFromE2, uint64(subReqCount)},
5208                 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5209                 Counter{cRestSubDelReqFromXapp, 1},
5210                 Counter{cSubDelReqToE2, uint64(subReqCount)},
5211                 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5212                 Counter{cRestSubDelRespToXapp, 1},
5213         })
5214
5215         // Req
5216         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5217         restSubId := xappConn1.SendRESTSubsReq(t, params)
5218         e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5219
5220         assert.Equal(t, len(e2SubsIds), subReqCount)
5221
5222         // Del
5223         xappConn1.SendRESTSubsDelReq(t, &restSubId)
5224         sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5225
5226         xappConn1.TestMsgChanEmpty(t)
5227         e2termConn1.TestMsgChanEmpty(t)
5228         mainCtrl.wait_registry_empty(t, 10)
5229
5230         mainCtrl.VerifyCounterValues(t)
5231 }
5232
5233 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
5234
5235         subReqCount := 19
5236
5237         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5238                 Counter{cRestSubReqFromXapp, 1},
5239                 Counter{cRestSubRespToXapp, 1},
5240                 Counter{cSubReqToE2, uint64(subReqCount)},
5241                 Counter{cSubRespFromE2, uint64(subReqCount)},
5242                 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5243                 Counter{cRestSubDelReqFromXapp, 1},
5244                 Counter{cSubDelReqToE2, uint64(subReqCount)},
5245                 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5246                 Counter{cRestSubDelRespToXapp, 1},
5247         })
5248
5249         // Req
5250         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5251         restSubId := xappConn1.SendRESTSubsReq(t, params)
5252         e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5253
5254         assert.Equal(t, len(e2SubsIds), subReqCount)
5255
5256         // Del
5257         xappConn1.SendRESTSubsDelReq(t, &restSubId)
5258         sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5259
5260         xappConn1.TestMsgChanEmpty(t)
5261         e2termConn1.TestMsgChanEmpty(t)
5262         mainCtrl.wait_registry_empty(t, 10)
5263
5264         mainCtrl.VerifyCounterValues(t)
5265 }
5266
5267 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
5268         CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
5269
5270         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5271                 Counter{cRestSubReqFromXapp, 2},
5272                 Counter{cRestSubRespToXapp, 2},
5273                 Counter{cSubReqToE2, 2},
5274                 Counter{cSubRespFromE2, 2},
5275                 Counter{cRestSubNotifToXapp, 2},
5276                 Counter{cRestSubDelReqFromXapp, 2},
5277                 Counter{cSubDelReqToE2, 2},
5278                 Counter{cSubDelRespFromE2, 2},
5279                 Counter{cRestSubDelRespToXapp, 2},
5280         })
5281
5282         // Req1
5283         var params *teststube2ap.RESTSubsReqParams = nil
5284
5285         //Subs Create
5286         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5287         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5288
5289         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5290
5291         // Req2
5292         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5293         params.SetMeid("RAN_NAME_1")
5294         eventTriggerDefinition := []int64{1234, 1}
5295         params.SetSubEventTriggerDefinition(eventTriggerDefinition)
5296
5297         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5298         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5299         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5300         xappConn2.ExpectRESTNotification(t, restSubId2)
5301         e2termConn1.SendSubsResp(t, crereq, cremsg)
5302         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5303
5304         deleteXapp1Subscription(t, &restSubId1)
5305         deleteXapp2Subscription(t, &restSubId2)
5306
5307         waitSubsCleanup(t, e2SubsId1, 10)
5308         waitSubsCleanup(t, e2SubsId2, 10)
5309
5310         mainCtrl.VerifyCounterValues(t)
5311
5312 }
5313
5314 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
5315         CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
5316
5317         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5318                 Counter{cRestSubReqFromXapp, 2},
5319                 Counter{cRestSubRespToXapp, 2},
5320                 Counter{cSubReqToE2, 2},
5321                 Counter{cSubRespFromE2, 2},
5322                 Counter{cRestSubNotifToXapp, 2},
5323                 Counter{cRestSubDelReqFromXapp, 2},
5324                 Counter{cSubDelReqToE2, 2},
5325                 Counter{cSubDelRespFromE2, 2},
5326                 Counter{cRestSubDelRespToXapp, 2},
5327         })
5328
5329         // Req1
5330         var params *teststube2ap.RESTSubsReqParams = nil
5331
5332         //Subs Create
5333         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5334         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5335
5336         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5337
5338         // Req2
5339         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5340         params.SetMeid("RAN_NAME_1")
5341
5342         actionId := int64(1)
5343         actionType := "report"
5344         actionDefinition := []int64{5678, 1}
5345         subsequestActionType := "continue"
5346         timeToWait := "w10ms"
5347         params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
5348
5349         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5350         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5351         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5352         xappConn2.ExpectRESTNotification(t, restSubId2)
5353         e2termConn1.SendSubsResp(t, crereq, cremsg)
5354         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5355
5356         deleteXapp1Subscription(t, &restSubId1)
5357         deleteXapp2Subscription(t, &restSubId2)
5358
5359         waitSubsCleanup(t, e2SubsId1, 10)
5360         waitSubsCleanup(t, e2SubsId2, 10)
5361
5362         mainCtrl.VerifyCounterValues(t)
5363
5364 }
5365
5366 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
5367         CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
5368
5369         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5370                 Counter{cRestSubReqFromXapp, 2},
5371                 Counter{cRestSubRespToXapp, 2},
5372                 Counter{cSubReqToE2, 2},
5373                 Counter{cSubRespFromE2, 2},
5374                 Counter{cRestSubNotifToXapp, 2},
5375                 Counter{cRestSubDelReqFromXapp, 2},
5376                 Counter{cSubDelReqToE2, 2},
5377                 Counter{cSubDelRespFromE2, 2},
5378                 Counter{cRestSubDelRespToXapp, 2},
5379         })
5380
5381         // Req1
5382         var params *teststube2ap.RESTSubsReqParams = nil
5383
5384         //Subs Create
5385         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5386         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5387
5388         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5389
5390         // Req2
5391         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5392         params.SetMeid("RAN_NAME_1")
5393         params.SetSubActionIDs(int64(2))
5394
5395         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5396         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5397         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5398         xappConn2.ExpectRESTNotification(t, restSubId2)
5399         e2termConn1.SendSubsResp(t, crereq, cremsg)
5400         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5401
5402         deleteXapp1Subscription(t, &restSubId1)
5403         deleteXapp2Subscription(t, &restSubId2)
5404
5405         waitSubsCleanup(t, e2SubsId1, 10)
5406         waitSubsCleanup(t, e2SubsId2, 10)
5407
5408         mainCtrl.VerifyCounterValues(t)
5409
5410 }
5411
5412 func TestRESTSubReqDiffActionType(t *testing.T) {
5413         CaseBegin("TestRESTSubReqDiffActionType")
5414
5415         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5416                 Counter{cRestSubReqFromXapp, 2},
5417                 Counter{cRestSubRespToXapp, 2},
5418                 Counter{cSubReqToE2, 2},
5419                 Counter{cSubRespFromE2, 2},
5420                 Counter{cRestSubNotifToXapp, 2},
5421                 Counter{cRestSubDelReqFromXapp, 2},
5422                 Counter{cSubDelReqToE2, 2},
5423                 Counter{cSubDelRespFromE2, 2},
5424                 Counter{cRestSubDelRespToXapp, 2},
5425         })
5426
5427         // Req1
5428         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5429
5430         //Subs Create
5431         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5432         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5433
5434         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5435
5436         // Req2
5437         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5438         params.SetMeid("RAN_NAME_1")
5439
5440         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5441         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5442         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5443         xappConn2.ExpectRESTNotification(t, restSubId2)
5444         e2termConn1.SendSubsResp(t, crereq, cremsg)
5445         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5446
5447         deleteXapp1Subscription(t, &restSubId1)
5448         deleteXapp2Subscription(t, &restSubId2)
5449
5450         waitSubsCleanup(t, e2SubsId1, 10)
5451         waitSubsCleanup(t, e2SubsId2, 10)
5452
5453         mainCtrl.VerifyCounterValues(t)
5454
5455 }
5456
5457 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
5458         CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
5459
5460         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5461                 Counter{cRestSubReqFromXapp, 2},
5462                 Counter{cRestSubRespToXapp, 2},
5463                 Counter{cSubReqToE2, 2},
5464                 Counter{cSubRespFromE2, 2},
5465                 Counter{cRestSubNotifToXapp, 2},
5466                 Counter{cRestSubDelReqFromXapp, 2},
5467                 Counter{cSubDelReqToE2, 2},
5468                 Counter{cSubDelRespFromE2, 2},
5469                 Counter{cRestSubDelRespToXapp, 2},
5470         })
5471
5472         // Req1
5473         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5474
5475         //Subs Create
5476         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5477         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5478
5479         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5480
5481         // Req2
5482         params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
5483         params.SetMeid("RAN_NAME_1")
5484
5485         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5486         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5487         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5488         xappConn2.ExpectRESTNotification(t, restSubId2)
5489         e2termConn1.SendSubsResp(t, crereq, cremsg)
5490         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5491
5492         deleteXapp1Subscription(t, &restSubId1)
5493         deleteXapp2Subscription(t, &restSubId2)
5494
5495         waitSubsCleanup(t, e2SubsId1, 10)
5496         waitSubsCleanup(t, e2SubsId2, 10)
5497
5498         mainCtrl.VerifyCounterValues(t)
5499
5500 }
5501
5502 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
5503         CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
5504
5505         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5506                 Counter{cRestSubReqFromXapp, 2},
5507                 Counter{cRestSubRespToXapp, 2},
5508                 Counter{cSubReqToE2, 2},
5509                 Counter{cSubRespFromE2, 2},
5510                 Counter{cRestSubNotifToXapp, 2},
5511                 Counter{cRestSubDelReqFromXapp, 2},
5512                 Counter{cSubDelReqToE2, 2},
5513                 Counter{cSubDelRespFromE2, 2},
5514                 Counter{cRestSubDelRespToXapp, 2},
5515         })
5516
5517         // Req1
5518         var params *teststube2ap.RESTSubsReqParams = nil
5519
5520         //Subs Create
5521         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5522         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5523
5524         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5525
5526         // Req2
5527         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5528         params.SetMeid("RAN_NAME_1")
5529         actionDefinition := []int64{5678, 1}
5530         params.SetSubActionDefinition(actionDefinition)
5531
5532         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5533         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5534         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5535         xappConn2.ExpectRESTNotification(t, restSubId2)
5536         e2termConn1.SendSubsResp(t, crereq, cremsg)
5537         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5538
5539         deleteXapp1Subscription(t, &restSubId1)
5540         deleteXapp2Subscription(t, &restSubId2)
5541
5542         waitSubsCleanup(t, e2SubsId1, 10)
5543         waitSubsCleanup(t, e2SubsId2, 10)
5544
5545         mainCtrl.VerifyCounterValues(t)
5546
5547 }
5548
5549 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
5550         CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
5551
5552         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5553                 Counter{cRestSubReqFromXapp, 2},
5554                 Counter{cRestSubRespToXapp, 2},
5555                 Counter{cSubReqToE2, 2},
5556                 Counter{cSubRespFromE2, 2},
5557                 Counter{cRestSubNotifToXapp, 2},
5558                 Counter{cRestSubDelReqFromXapp, 2},
5559                 Counter{cSubDelReqToE2, 2},
5560                 Counter{cSubDelRespFromE2, 2},
5561                 Counter{cRestSubDelRespToXapp, 2},
5562         })
5563
5564         // Req1
5565         var params *teststube2ap.RESTSubsReqParams = nil
5566
5567         //Subs Create
5568         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5569         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5570
5571         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5572
5573         // Req2
5574         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5575         params.SetMeid("RAN_NAME_1")
5576         actionDefinition := []int64{56782}
5577         params.SetSubActionDefinition(actionDefinition)
5578
5579         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5580         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5581         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5582         xappConn2.ExpectRESTNotification(t, restSubId2)
5583         e2termConn1.SendSubsResp(t, crereq, cremsg)
5584         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5585
5586         deleteXapp1Subscription(t, &restSubId1)
5587         deleteXapp2Subscription(t, &restSubId2)
5588
5589         waitSubsCleanup(t, e2SubsId1, 10)
5590         waitSubsCleanup(t, e2SubsId2, 10)
5591
5592         mainCtrl.VerifyCounterValues(t)
5593
5594 }
5595
5596 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
5597         CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
5598
5599         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5600                 Counter{cRestSubReqFromXapp, 2},
5601                 Counter{cRestSubRespToXapp, 2},
5602                 Counter{cSubReqToE2, 2},
5603                 Counter{cSubRespFromE2, 2},
5604                 Counter{cRestSubNotifToXapp, 2},
5605                 Counter{cRestSubDelReqFromXapp, 2},
5606                 Counter{cSubDelReqToE2, 2},
5607                 Counter{cSubDelRespFromE2, 2},
5608                 Counter{cRestSubDelRespToXapp, 2},
5609         })
5610
5611         // Req1
5612         var params *teststube2ap.RESTSubsReqParams = nil
5613
5614         //Subs Create
5615         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5616         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
5617
5618         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5619
5620         // Req2
5621         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5622         params.SetMeid("RAN_NAME_1")
5623         params.SetTimeToWait("w200ms")
5624         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5625         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
5626         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5627         xappConn2.ExpectRESTNotification(t, restSubId2)
5628         e2termConn1.SendSubsResp(t, crereq, cremsg)
5629         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5630
5631         deleteXapp1Subscription(t, &restSubId1)
5632         deleteXapp2Subscription(t, &restSubId2)
5633
5634         waitSubsCleanup(t, e2SubsId1, 10)
5635         waitSubsCleanup(t, e2SubsId2, 10)
5636
5637         mainCtrl.VerifyCounterValues(t)
5638
5639 }
5640
5641 //-----------------------------------------------------------------------------
5642 // TestRESTUnpackSubscriptionResponseDecodeFail
5643 //
5644 //   stub                             stub
5645 // +-------+        +---------+    +---------+
5646 // | xapp  |        | submgr  |    | e2term  |
5647 // +-------+        +---------+    +---------+
5648 //     |                 |              |
5649 //     | RestSubReq      |              |
5650 //     |---------------->|              |
5651 //     |                 |              |
5652 //     |     RESTSubResp |              |
5653 //     |<----------------|              |
5654 //     |                 |              |
5655 //     |                 | SubReq       |
5656 //     |                 |------------->|
5657 //     |                 |              |
5658 //     |                 |      SubResp | ASN.1 decode fails
5659 //     |                 |<-------------|
5660 //     |                 |              |
5661 //     |                 | SubReq       |
5662 //     |                 |------------->|
5663 //     |                 |              |
5664 //     |                 |      SubFail | Duplicated action
5665 //     |                 |<-------------|
5666 //     | RESTNotif (fail)|              |
5667 //     |<----------------|              |
5668 //     |                 | SubDelReq    |
5669 //     |                 |------------->|
5670 //     |                 |              |
5671 //     |                 |   SubDelResp |
5672 //     |                 |<-------------|
5673 //
5674 //-----------------------------------------------------------------------------
5675
5676 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
5677         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
5678         subReqCount := 1
5679
5680         // Req
5681         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5682         restSubId := xappConn1.SendRESTSubsReq(t, params)
5683
5684         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5685         // Decode of this response fails which will result resending original request
5686         e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
5687
5688         _, cremsg = e2termConn1.RecvSubsReq(t)
5689
5690         xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
5691
5692         // Subscription already created in E2 Node.
5693         fparams := &teststube2ap.E2StubSubsFailParams{}
5694         fparams.Set(crereq)
5695         fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5696         e2termConn1.SendSubsFail(t, fparams, cremsg)
5697
5698         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5699         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5700
5701         instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5702         xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5703
5704         // Wait that subs is cleaned
5705         mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5706
5707         xappConn1.TestMsgChanEmpty(t)
5708         e2termConn1.TestMsgChanEmpty(t)
5709         mainCtrl.wait_registry_empty(t, 10)
5710 }
5711
5712 //-----------------------------------------------------------------------------
5713 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
5714 //
5715 //   stub                             stub
5716 // +-------+        +---------+    +---------+
5717 // | xapp  |        | submgr  |    | e2term  |
5718 // +-------+        +---------+    +---------+
5719 //     |                 |              |
5720 //     | RestSubReq      |              |
5721 //     |---------------->|              |
5722 //     |                 |              |
5723 //     |     RESTSubResp |              |
5724 //     |<----------------|              |
5725 //     |                 |              |
5726 //     |                 | SubReq       |
5727 //     |                 |------------->|
5728 //     |                 |              |
5729 //     |                 |      SubResp | Unknown instanceId
5730 //     |                 |<-------------|
5731 //     |                 |              |
5732 //     |                 | SubReq       |
5733 //     |                 |------------->|
5734 //     |                 |              |
5735 //     |                 |      SubFail | Duplicated action
5736 //     |                 |<-------------|
5737 //     | RESTNotif (fail)|              |
5738 //     |<----------------|              |
5739 //     |                 | SubDelReq    |
5740 //     |                 |------------->|
5741 //     |                 |              |
5742 //     |                 |   SubDelResp |
5743 //     |                 |<-------------|
5744 //
5745 //-----------------------------------------------------------------------------
5746
5747 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
5748         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
5749         subReqCount := 1
5750
5751         // Req
5752         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5753         restSubId := xappConn1.SendRESTSubsReq(t, params)
5754
5755         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5756
5757         // Unknown instanceId in this response which will result resending original request
5758         orgInstanceId := crereq.RequestId.InstanceId
5759         crereq.RequestId.InstanceId = 0
5760         e2termConn1.SendSubsResp(t, crereq, cremsg)
5761
5762         _, cremsg = e2termConn1.RecvSubsReq(t)
5763
5764         xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
5765
5766         // Subscription already created in E2 Node.
5767         fparams := &teststube2ap.E2StubSubsFailParams{}
5768         fparams.Set(crereq)
5769         fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5770         e2termConn1.SendSubsFail(t, fparams, cremsg)
5771
5772         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5773         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5774
5775         instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5776         xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5777
5778         // Wait that subs is cleaned
5779         mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
5780
5781         xappConn1.TestMsgChanEmpty(t)
5782         e2termConn1.TestMsgChanEmpty(t)
5783         mainCtrl.wait_registry_empty(t, 10)
5784 }
5785
5786 //-----------------------------------------------------------------------------
5787 // TestRESTUnpackSubscriptionResponseNoTransaction
5788 //
5789 //   stub                             stub
5790 // +-------+        +---------+    +---------+
5791 // | xapp  |        | submgr  |    | e2term  |
5792 // +-------+        +---------+    +---------+
5793 //     |                 |              |
5794 //     | RestSubReq      |              |
5795 //     |---------------->|              |
5796 //     |                 |              |
5797 //     |     RESTSubResp |              |
5798 //     |<----------------|              |
5799 //     |                 |              |
5800 //     |                 | SubReq       |
5801 //     |                 |------------->|
5802 //     |                 |              |
5803 //     |                 |      SubResp | No transaction for the response
5804 //     |                 |<-------------|
5805 //     |                 |              |
5806 //     |                 | SubReq       |
5807 //     |                 |------------->|
5808 //     |                 |              |
5809 //     |                 |      SubFail | Duplicated action
5810 //     |                 |<-------------|
5811 //     | RESTNotif (fail)|              |
5812 //     |<----------------|              |
5813 //     |                 | SubDelReq    |
5814 //     |                 |------------->|
5815 //     |                 |              |
5816 //     |                 |   SubDelResp |
5817 //     |                 |<-------------|
5818 //     |                 |              |
5819 //     |                 | SubDelReq    |
5820 //     |                 |------------->|
5821 //     |                 |              |
5822 //     |                 |   SubDelResp |
5823 //     |                 |<-------------|
5824 //
5825 //-----------------------------------------------------------------------------
5826 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
5827         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
5828         subReqCount := 1
5829
5830         // Req
5831         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5832         restSubId := xappConn1.SendRESTSubsReq(t, params)
5833
5834         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5835
5836         mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
5837         // No transaction exist for this response which will result resending original request
5838         e2termConn1.SendSubsResp(t, crereq, cremsg)
5839
5840         _, cremsg = e2termConn1.RecvSubsReq(t)
5841
5842         xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
5843
5844         // Subscription already created in E2 Node.
5845         fparams := &teststube2ap.E2StubSubsFailParams{}
5846         fparams.Set(crereq)
5847         fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5848         e2termConn1.SendSubsFail(t, fparams, cremsg)
5849
5850         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5851         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5852
5853         // Resending happens because there no transaction
5854         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
5855         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5856
5857         instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5858         xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5859
5860         // Wait that subs is cleaned
5861         mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5862
5863         xappConn1.TestMsgChanEmpty(t)
5864         e2termConn1.TestMsgChanEmpty(t)
5865         mainCtrl.wait_registry_empty(t, 10)
5866
5867 }
5868
5869 //-----------------------------------------------------------------------------
5870 // TestRESTUnpackSubscriptionFailureDecodeFail
5871 //
5872 //   stub                             stub
5873 // +-------+        +---------+    +---------+
5874 // | xapp  |        | submgr  |    | e2term  |
5875 // +-------+        +---------+    +---------+
5876 //     |                 |              |
5877 //     | RestSubReq      |              |
5878 //     |---------------->|              |
5879 //     |                 |              |
5880 //     |     RESTSubResp |              |
5881 //     |<----------------|              |
5882 //     |                 |              |
5883 //     |                 | SubReq       |
5884 //     |                 |------------->|
5885 //     |                 |              |
5886 //     |                 |      SubFail | ASN.1 decode fails
5887 //     |                 |<-------------|
5888 //     |                 |              |
5889 //     |                 | SubReq       |
5890 //     |                 |------------->|
5891 //     |                 |              |
5892 //     |                 |      SubFail | Duplicated action
5893 //     |                 |<-------------|
5894 //     | RESTNotif (fail)|              |
5895 //     |<----------------|              |
5896 //     |                 | SubDelReq    |
5897 //     |                 |------------->|
5898 //     |                 |              |
5899 //     |                 |   SubDelResp |
5900 //     |                 |<-------------|
5901 //
5902 //-----------------------------------------------------------------------------
5903 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
5904         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
5905         subReqCount := 1
5906
5907         // Req
5908         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5909         restSubId := xappConn1.SendRESTSubsReq(t, params)
5910
5911         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5912
5913         // Decode of this response fails which will result resending original request
5914         e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
5915
5916         _, cremsg = e2termConn1.RecvSubsReq(t)
5917
5918         xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
5919
5920         // Subscription already created in E2 Node.
5921         fparams := &teststube2ap.E2StubSubsFailParams{}
5922         fparams.Set(crereq)
5923         fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5924         e2termConn1.SendSubsFail(t, fparams, cremsg)
5925
5926         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5927         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5928
5929         instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5930         xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
5931
5932         // Wait that subs is cleaned
5933         mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5934
5935         xappConn1.TestMsgChanEmpty(t)
5936         e2termConn1.TestMsgChanEmpty(t)
5937         mainCtrl.wait_registry_empty(t, 10)
5938 }
5939
5940 //-----------------------------------------------------------------------------
5941 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
5942 //
5943 //   stub                             stub
5944 // +-------+        +---------+    +---------+
5945 // | xapp  |        | submgr  |    | e2term  |
5946 // +-------+        +---------+    +---------+
5947 //     |                 |              |
5948 //     | RestSubReq      |              |
5949 //     |---------------->|              |
5950 //     |                 |              |
5951 //     |     RESTSubResp |              |
5952 //     |<----------------|              |
5953 //     |                 |              |
5954 //     |                 | SubReq       |
5955 //     |                 |------------->|
5956 //     |                 |              |
5957 //     |                 |      SubFail | Unknown instanceId
5958 //     |                 |<-------------|
5959 //     |                 |              |
5960 //     |                 | SubReq       |
5961 //     |                 |------------->|
5962 //     |                 |              |
5963 //     |                 |      SubFail | Duplicated action
5964 //     |                 |<-------------|
5965 //     | RESTNotif (fail)|              |
5966 //     |<----------------|              |
5967 //     |                 | SubDelReq    |
5968 //     |                 |------------->|
5969 //     |                 |              |
5970 //     |                 |   SubDelResp |
5971 //     |                 |<-------------|
5972 //
5973 //-----------------------------------------------------------------------------
5974 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
5975         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
5976         subReqCount := 1
5977
5978         // Req
5979         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5980         restSubId := xappConn1.SendRESTSubsReq(t, params)
5981
5982         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5983
5984         // Unknown instanceId in this response which will result resending original request
5985         fparams := &teststube2ap.E2StubSubsFailParams{}
5986         fparams.Set(crereq)
5987         fparams.Fail.RequestId.InstanceId = 0
5988         e2termConn1.SendSubsFail(t, fparams, cremsg)
5989
5990         _, cremsg = e2termConn1.RecvSubsReq(t)
5991
5992         xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
5993
5994         // Subscription already created in E2 Node.
5995         fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5996         e2termConn1.SendSubsFail(t, fparams, cremsg)
5997
5998         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5999         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6000
6001         instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6002         xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
6003
6004         // Wait that subs is cleaned
6005         mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6006
6007         xappConn1.TestMsgChanEmpty(t)
6008         e2termConn1.TestMsgChanEmpty(t)
6009         mainCtrl.wait_registry_empty(t, 10)
6010 }
6011
6012 //-----------------------------------------------------------------------------
6013 // TestRESTUnpackSubscriptionFailureNoTransaction
6014 //
6015 //   stub                             stub
6016 // +-------+        +---------+    +---------+
6017 // | xapp  |        | submgr  |    | e2term  |
6018 // +-------+        +---------+    +---------+
6019 //     |                 |              |
6020 //     | RestSubReq      |              |
6021 //     |---------------->|              |
6022 //     |                 |              |
6023 //     |     RESTSubResp |              |
6024 //     |<----------------|              |
6025 //     |                 |              |
6026 //     |                 | SubReq       |
6027 //     |                 |------------->|
6028 //     |                 |              |
6029 //     |                 |      SubFail | No transaction for the response
6030 //     |                 |<-------------|
6031 //     |                 |              |
6032 //     |                 | SubReq       |
6033 //     |                 |------------->|
6034 //     |                 |              |
6035 //     |                 |      SubFail | Duplicated action
6036 //     |                 |<-------------|
6037 //     | RESTNotif (fail)|              |
6038 //     |<----------------|              |
6039 //     |                 | SubDelReq    |
6040 //     |                 |------------->|
6041 //     |                 |              |
6042 //     |                 |   SubDelResp |
6043 //     |                 |<-------------|
6044 //
6045 //-----------------------------------------------------------------------------
6046 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
6047         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
6048         subReqCount := 1
6049
6050         // Req
6051         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6052         restSubId := xappConn1.SendRESTSubsReq(t, params)
6053
6054         crereq, cremsg := e2termConn1.RecvSubsReq(t)
6055
6056         mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6057
6058         // No transaction exist for this response which will result resending original request
6059         fparams := &teststube2ap.E2StubSubsFailParams{}
6060         fparams.Set(crereq)
6061         e2termConn1.SendSubsFail(t, fparams, cremsg)
6062
6063         _, cremsg = e2termConn1.RecvSubsReq(t)
6064
6065         xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6066
6067         // Subscription already created in E2 Node.
6068         fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6069         e2termConn1.SendSubsFail(t, fparams, cremsg)
6070
6071         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6072         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6073
6074         // Resending happens because there no transaction
6075         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6076         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6077
6078         instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6079         xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
6080
6081         // Wait that subs is cleaned
6082         mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6083
6084         xappConn1.TestMsgChanEmpty(t)
6085         e2termConn1.TestMsgChanEmpty(t)
6086         mainCtrl.wait_registry_empty(t, 10)
6087 }
6088
6089 //-----------------------------------------------------------------------------
6090 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
6091 //
6092 //   stub                             stub
6093 // +-------+        +---------+    +---------+
6094 // | xapp  |        | submgr  |    | e2term  |
6095 // +-------+        +---------+    +---------+
6096 //     |                 |              |
6097 //     |            [SUBS CREATE]       |
6098 //     |                 |              |
6099 //     |                 |              |
6100 //     | RESTSubDelReq   |              |
6101 //     |---------------->|              |
6102 //     |                 |              |
6103 //     |  RESTSubDelResp |              |
6104 //     |<----------------|              |
6105 //     |                 |              |
6106 //     |                 | SubDelReq    |
6107 //     |                 |------------->|
6108 //     |                 |              |
6109 //     |                 |   SubDelResp | ASN.1 decode fails
6110 //     |                 |<-------------|
6111 //     |                 |              |
6112 //     |                 | SubDelReq    |
6113 //     |                 |------------->|
6114 //     |                 |              |
6115 //     |                 |   SubDelFail | Subscription does exist any more
6116 //     |                 |<-------------|
6117 //     |                 |              |
6118 //
6119 //-----------------------------------------------------------------------------
6120 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
6121         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail")
6122
6123         // Req
6124         var params *teststube2ap.RESTSubsReqParams = nil
6125         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6126
6127         // Del
6128         xappConn1.SendRESTSubsDelReq(t, &restSubId)
6129
6130         // E2t: Receive 1st SubsDelReq
6131         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6132
6133         // Decode of this response fails which will result resending original request
6134         e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_REQ)
6135
6136         // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6137         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6138
6139         // Subscription does not exist in in E2 Node.
6140         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6141
6142         // Wait that subs is cleaned
6143         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6144
6145         xappConn1.TestMsgChanEmpty(t)
6146         e2termConn1.TestMsgChanEmpty(t)
6147         mainCtrl.wait_registry_empty(t, 10)
6148 }
6149
6150 //-----------------------------------------------------------------------------
6151 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
6152 //
6153 //   stub                             stub
6154 // +-------+        +---------+    +---------+
6155 // | xapp  |        | submgr  |    | e2term  |
6156 // +-------+        +---------+    +---------+
6157 //     |                 |              |
6158 //     |            [SUBS CREATE]       |
6159 //     |                 |              |
6160 //     |                 |              |
6161 //     | RESTSubDelReq   |              |
6162 //     |---------------->|              |
6163 //     |                 |              |
6164 //     |  RESTSubDelResp |              |
6165 //     |<----------------|              |
6166 //     |                 |              |
6167 //     |                 | SubDelReq    |
6168 //     |                 |------------->|
6169 //     |                 |              |
6170 //     |                 |   SubDelResp | Unknown instanceId
6171 //     |                 |<-------------|
6172 //     |                 |              |
6173 //     |                 | SubDelReq    |
6174 //     |                 |------------->|
6175 //     |                 |              |
6176 //     |                 |   SubDelFail | Subscription does exist any more
6177 //     |                 |<-------------|
6178 //
6179 //-----------------------------------------------------------------------------
6180 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
6181         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId")
6182
6183         // Req
6184         var params *teststube2ap.RESTSubsReqParams = nil
6185         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6186
6187         // Del
6188         xappConn1.SendRESTSubsDelReq(t, &restSubId)
6189
6190         // E2t: Receive 1st SubsDelReq
6191         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6192
6193         // Unknown instanceId in this response which will result resending original request
6194         delreq.RequestId.InstanceId = 0
6195         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6196
6197         // E2t: Receive 2nd SubsDelReq
6198         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6199
6200         // Subscription does not exist in in E2 Node.
6201         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6202
6203         // Wait that subs is cleaned
6204         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6205
6206         xappConn1.TestMsgChanEmpty(t)
6207         e2termConn1.TestMsgChanEmpty(t)
6208         mainCtrl.wait_registry_empty(t, 10)
6209 }
6210
6211 //-----------------------------------------------------------------------------
6212 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
6213 //
6214 //   stub                             stub
6215 // +-------+        +---------+    +---------+
6216 // | xapp  |        | submgr  |    | e2term  |
6217 // +-------+        +---------+    +---------+
6218 //     |                 |              |
6219 //     |            [SUBS CREATE]       |
6220 //     |                 |              |
6221 //     |                 |              |
6222 //     | RESTSubDelReq   |              |
6223 //     |---------------->|              |
6224 //     |                 |              |
6225 //     |  RESTSubDelResp |              |
6226 //     |<----------------|              |
6227 //     |                 |              |
6228 //     |                 | SubDelReq    |
6229 //     |                 |------------->|
6230 //     |                 |              |
6231 //     |                 |   SubDelResp | No transaction for the response
6232 //     |                 |<-------------|
6233 //     |                 |              |
6234 //     |                 | SubDelReq    |
6235 //     |                 |------------->|
6236 //     |                 |              |
6237 //     |                 |   SubDelFail | Subscription does exist any more
6238 //     |                 |<-------------|
6239 //
6240 //-----------------------------------------------------------------------------
6241 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
6242         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction")
6243
6244         // Req
6245         var params *teststube2ap.RESTSubsReqParams = nil
6246         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6247
6248         // Del
6249         xappConn1.SendRESTSubsDelReq(t, &restSubId)
6250
6251         // E2t: Receive 1st SubsDelReq
6252         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6253
6254         mainCtrl.MakeTransactionNil(t, e2SubsId)
6255
6256         // No transaction exist for this response which will result resending original request
6257         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6258
6259         // E2t: Receive 2nd SubsDelReq
6260         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6261
6262         // Subscription does not exist in in E2 Node.
6263         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6264
6265         // Wait that subs is cleaned
6266         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6267
6268         xappConn1.TestMsgChanEmpty(t)
6269         e2termConn1.TestMsgChanEmpty(t)
6270         mainCtrl.wait_registry_empty(t, 10)
6271 }
6272
6273 //-----------------------------------------------------------------------------
6274 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
6275 //
6276 //   stub                             stub
6277 // +-------+        +---------+    +---------+
6278 // | xapp  |        | submgr  |    | e2term  |
6279 // +-------+        +---------+    +---------+
6280 //     |                 |              |
6281 //     |            [SUBS CREATE]       |
6282 //     |                 |              |
6283 //     |                 |              |
6284 //     | RESTSubDelReq   |              |
6285 //     |---------------->|              |
6286 //     |                 |              |
6287 //     |  RESTSubDelResp |              |
6288 //     |<----------------|              |
6289 //     |                 |              |
6290 //     |                 | SubDelReq    |
6291 //     |                 |------------->|
6292 //     |                 |              |
6293 //     |                 |   SubDelFail | ASN.1 decode fails
6294 //     |                 |<-------------|
6295 //     |                 |              |
6296 //     |                 | SubDelReq    |
6297 //     |                 |------------->|
6298 //     |                 |              |
6299 //     |                 |   SubDelFail | Subscription does exist any more
6300 //     |                 |<-------------|
6301 //
6302 //-----------------------------------------------------------------------------
6303 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
6304         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail")
6305
6306         // Req
6307         var params *teststube2ap.RESTSubsReqParams = nil
6308         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6309
6310         // Del
6311         xappConn1.SendRESTSubsDelReq(t, &restSubId)
6312
6313         // E2t: Receive 1st SubsDelReq
6314         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6315
6316         // Decode of this response fails which will result resending original request
6317         e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
6318
6319         // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6320         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6321
6322         // Subscription does not exist in in E2 Node.
6323         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6324
6325         // Wait that subs is cleaned
6326         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6327
6328         xappConn1.TestMsgChanEmpty(t)
6329         e2termConn1.TestMsgChanEmpty(t)
6330         mainCtrl.wait_registry_empty(t, 10)
6331 }
6332
6333 //-----------------------------------------------------------------------------
6334 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
6335 //
6336 //   stub                             stub
6337 // +-------+        +---------+    +---------+
6338 // | xapp  |        | submgr  |    | e2term  |
6339 // +-------+        +---------+    +---------+
6340 //     |                 |              |
6341 //     |            [SUBS CREATE]       |
6342 //     |                 |              |
6343 //     |                 |              |
6344 //     | RESTSubDelReq   |              |
6345 //     |---------------->|              |
6346 //     |                 |              |
6347 //     |  RESTSubDelResp |              |
6348 //     |<----------------|              |
6349 //     |                 |              |
6350 //     |                 | SubDelReq    |
6351 //     |                 |------------->|
6352 //     |                 |              |
6353 //     |                 |   SubDelFail | Unknown instanceId
6354 //     |                 |<-------------|
6355 //     |                 |              |
6356 //     |                 | SubDelReq    |
6357 //     |                 |------------->|
6358 //     |                 |              |
6359 //     |                 |   SubDelFail | Subscription does exist any more
6360 //     |                 |<-------------|
6361 //
6362 //-----------------------------------------------------------------------------
6363 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
6364         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId")
6365
6366         // Req
6367         var params *teststube2ap.RESTSubsReqParams = nil
6368         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6369
6370         // Del
6371         xappConn1.SendRESTSubsDelReq(t, &restSubId)
6372
6373         // E2t: Receive 1st SubsDelReq
6374         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6375
6376         // Unknown instanceId in this response which will result resending original request
6377         delreq.RequestId.InstanceId = 0
6378         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6379
6380         // E2t: Receive 2nd SubsDelReq
6381         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6382
6383         // Subscription does not exist in in E2 Node.
6384         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6385
6386         // Wait that subs is cleaned
6387         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6388
6389         xappConn1.TestMsgChanEmpty(t)
6390         e2termConn1.TestMsgChanEmpty(t)
6391         mainCtrl.wait_registry_empty(t, 10)
6392 }
6393
6394 //-----------------------------------------------------------------------------
6395 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
6396 //
6397 //   stub                             stub
6398 // +-------+        +---------+    +---------+
6399 // | xapp  |        | submgr  |    | e2term  |
6400 // +-------+        +---------+    +---------+
6401 //     |                 |              |
6402 //     |            [SUBS CREATE]       |
6403 //     |                 |              |
6404 //     |                 |              |
6405 //     | RESTSubDelReq   |              |
6406 //     |---------------->|              |
6407 //     |                 |              |
6408 //     |  RESTSubDelResp |              |
6409 //     |<----------------|              |
6410 //     |                 |              |
6411 //     |                 | SubDelReq    |
6412 //     |                 |------------->|
6413 //     |                 |              |
6414 //     |                 |   SubDelFail | No transaction for the response
6415 //     |                 |<-------------|
6416 //     |                 |              |
6417 //     |                 | SubDelReq    |
6418 //     |                 |------------->|
6419 //     |                 |              |
6420 //     |                 |   SubDelFail | Subscription does exist any more
6421 //     |                 |<-------------|
6422 //
6423 //-----------------------------------------------------------------------------
6424 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
6425         xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction")
6426
6427         // Req
6428         var params *teststube2ap.RESTSubsReqParams = nil
6429         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6430
6431         // Del
6432         xappConn1.SendRESTSubsDelReq(t, &restSubId)
6433
6434         // E2t: Receive 1st SubsDelReq
6435         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6436
6437         mainCtrl.MakeTransactionNil(t, e2SubsId)
6438
6439         // No transaction exist for this response which will result resending original request
6440         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6441
6442         // E2t: Receive 2nd SubsDelReq
6443         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6444
6445         // Subscription does not exist in in E2 Node.
6446         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6447
6448         // Wait that subs is cleaned
6449         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6450
6451         xappConn1.TestMsgChanEmpty(t)
6452         e2termConn1.TestMsgChanEmpty(t)
6453         mainCtrl.wait_registry_empty(t, 10)
6454 }
6455
6456 //-----------------------------------------------------------------------------
6457 // TestRESTSubReqFailAsn1PackSubReqError
6458 //
6459 //   stub                             stub
6460 // +-------+        +---------+    +---------+
6461 // | xapp  |        | submgr  |    | e2term  |
6462 // +-------+        +---------+    +---------+
6463 //     |                 |              |
6464 //     | RESTSubReq      |              |
6465 //     |---------------->|              |
6466 //     |                 |              |
6467 //     |     RESTSubResp |              |
6468 //     |<----------------|              |
6469 //     |                 |              |
6470 //     |        ASN.1 encode fails      |
6471 //     |                 |              |
6472 //     |                 | SubDelReq    |
6473 //     |                 |------------->|
6474 //     |                 |              |
6475 //     |                 |  SubDelFail  |
6476 //     |                 |<-------------|
6477 //     |                 |              |
6478 //     |       RESTNotif |              |
6479 //     |       unsuccess |              |
6480 //     |<----------------|              |
6481 //     |                 |              |
6482 //     |            [SUBS DELETE]       |
6483 //     |                 |              |
6484 //
6485 //-----------------------------------------------------------------------------
6486 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
6487
6488         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6489                 Counter{cRestSubReqFromXapp, 1},
6490                 Counter{cRestSubRespToXapp, 1},
6491                 Counter{cSubDelReqToE2, 1},
6492                 Counter{cSubDelFailFromE2, 1},
6493                 Counter{cRestSubFailNotifToXapp, 1},
6494         })
6495
6496         subReqCount := 1
6497
6498         var params *teststube2ap.RESTSubsReqParams = nil
6499         params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
6500         e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
6501
6502         // Req
6503         restSubId := xappConn1.SendRESTSubsReq(t, params)
6504         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
6505
6506         // E2t: Receive SubsDelReq
6507         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6508         xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6509
6510         // Subscription does not exist in in E2 Node.
6511         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6512
6513         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6514         xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
6515
6516         e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
6517         // Wait that subs is cleaned
6518         waitSubsCleanup(t, e2SubsId, 10)
6519         mainCtrl.VerifyCounterValues(t)
6520 }
6521
6522 ////////////////////////////////////////////////////////////////////////////////////
6523 //   Services for UT cases
6524 ////////////////////////////////////////////////////////////////////////////////////
6525 const subReqCount int = 1
6526 const host string = "localhost"
6527
6528 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
6529         if params == nil {
6530                 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
6531         }
6532         restSubId := fromXappConn.SendRESTSubsReq(t, params)
6533         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
6534
6535         crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
6536         fromXappConn.ExpectRESTNotification(t, restSubId)
6537         toE2termConn.SendSubsResp(t, crereq1, cremsg1)
6538         e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
6539         xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
6540
6541         return restSubId, e2SubsId
6542 }
6543
6544 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
6545
6546         params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
6547         if meid != "" {
6548                 params.SetMeid(meid)
6549         }
6550         xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
6551         restSubId := xappConn2.SendRESTSubsReq(t, params)
6552         xappConn2.ExpectRESTNotification(t, restSubId)
6553         xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
6554         e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
6555         xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
6556
6557         return restSubId, e2SubsId
6558 }
6559
6560 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
6561         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6562         restSubId := xappConn1.SendRESTSubsReq(t, params)
6563         xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
6564
6565         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6566         xappConn1.ExpectRESTNotification(t, restSubId)
6567         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
6568         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6569         xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
6570
6571         return restSubId, e2SubsId
6572 }
6573
6574 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
6575         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6576         restSubId := xappConn1.SendRESTSubsReq(t, params)
6577
6578         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6579         fparams1 := &teststube2ap.E2StubSubsFailParams{}
6580         fparams1.Set(crereq1)
6581         e2termConn1.SendSubsFail(t, fparams1, cremsg1)
6582
6583         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
6584         xappConn1.ExpectRESTNotification(t, restSubId)
6585         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
6586         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6587         xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
6588
6589         return restSubId, e2SubsId
6590 }
6591
6592 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
6593         fromXappConn.SendRESTSubsDelReq(t, restSubId)
6594         delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
6595         toE2termConn.SendSubsDelResp(t, delreq, delmsg)
6596 }
6597
6598 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
6599         xappConn1.SendRESTSubsDelReq(t, restSubId)
6600         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6601         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6602 }
6603
6604 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
6605         xappConn2.SendRESTSubsDelReq(t, restSubId)
6606         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6607         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6608 }
6609
6610 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
6611         resp, _ := xapp.Subscription.QuerySubscriptions()
6612         assert.Equal(t, resp[0].SubscriptionID, e2SubsId)
6613         assert.Equal(t, resp[0].Meid, meid)
6614         assert.Equal(t, resp[0].ClientEndpoint, endpoint)
6615 }
6616
6617 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
6618         //Wait that subs is cleaned
6619         mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
6620
6621         xappConn1.TestMsgChanEmpty(t)
6622         xappConn2.TestMsgChanEmpty(t)
6623         e2termConn1.TestMsgChanEmpty(t)
6624         mainCtrl.wait_registry_empty(t, timeout)
6625 }
6626
6627 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
6628
6629         var e2SubsId []uint32
6630
6631         for i := 0; i < count; i++ {
6632                 xapp.Logger.Info("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
6633                 crereq, cremsg := toE2termConn.RecvSubsReq(t)
6634                 fromXappConn.ExpectRESTNotification(t, restSubId)
6635                 toE2termConn.SendSubsResp(t, crereq, cremsg)
6636                 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
6637                 e2SubsId = append(e2SubsId, instanceId)
6638                 xapp.Logger.Info("TEST: %v", e2SubsId)
6639                 xapp.Logger.Info("TEST: %d ===================================== END CRE ============================================", i+1)
6640                 <-time.After(100 * time.Millisecond)
6641         }
6642         return e2SubsId
6643 }
6644
6645 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
6646
6647         for i := 0; i < len(e2SubsIds); i++ {
6648                 xapp.Logger.Info("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
6649                 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
6650                 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
6651                 <-time.After(1 * time.Second)
6652                 xapp.Logger.Info("TEST: %d ===================================== END DEL ============================================", i+1)
6653                 <-time.After(100 * time.Millisecond)
6654         }
6655
6656         // Wait that subs is cleaned
6657         for i := 0; i < len(e2SubsIds); i++ {
6658                 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)
6659         }
6660
6661 }