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