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         subepcnt := mainCtrl.get_subs_entrypoint_cnt(t, e2SubsId1)
5262         xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5263         mainCtrl.wait_subs_entrypoint_cnt_change(t, e2SubsId1, subepcnt, 10)
5264
5265         // Above wait does not work correctly anymore as this delay makes this test case work
5266         //<-time.After(time.Second * 1)
5267
5268         mainCtrl.SimulateRestart(t)
5269         xapp.Logger.Debug("mainCtrl.SimulateRestart done 2")
5270
5271         // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
5272         // That needs to be completed before successful subscription query is possible
5273         <-time.After(time.Second * 1)
5274
5275         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
5276
5277         // Delete subscription 2
5278         deleteXapp2Subscription(t, &restSubId2)
5279
5280         //Wait that subs is cleaned
5281         waitSubsCleanup(t, e2SubsId2, 10)
5282
5283         mainCtrl.VerifyCounterValues(t)
5284         mainCtrl.VerifyAllClean(t)
5285 }
5286
5287 //-----------------------------------------------------------------------------
5288 // TestRESTReportSubReqAndSubDelOk
5289 //
5290 //   stub                             stub
5291 // +-------+        +---------+    +---------+
5292 // | xapp  |        | submgr  |    | e2term  |
5293 // +-------+        +---------+    +---------+
5294 //     |                 |              |
5295 //     | RestSubReq      |              |
5296 //     |---------------->|              |
5297 //     |                 |              |
5298 //     |     RESTSubResp |              |
5299 //     |<----------------|              |
5300 //     |                 |              |
5301 //     |                 | SubReq       |
5302 //     |                 |------------->|
5303 //     |                 |              |
5304 //     |                 |      SubResp |
5305 //     |                 |<-------------|
5306 //     | RESTNotif       |              |
5307 //     |<----------------|              |
5308 //     |                 | SubReq       |
5309 //     |                 |------------->|
5310 //     |                 |              |
5311 //     |                 |      SubResp |
5312 //     |                 |<-------------|
5313 //     | RESTNotif       |              |
5314 //     |<----------------|              |
5315 //     |       ...       |     ...      |
5316 //     |                 |              |
5317 //     |                 |              |
5318 //     | RESTSubDelReq   |              |
5319 //     |---------------->|              |
5320 //     |                 |              |
5321 //     |   RESTSubDelResp|              |
5322 //     |<----------------|              |
5323 //     |                 | SubDelReq    |
5324 //     |                 |------------->|
5325 //     |                 |              |
5326 //     |                 |   SubDelResp |
5327 //     |                 |<-------------|
5328 //     |                 |              |
5329 //
5330 //-----------------------------------------------------------------------------
5331
5332 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
5333         CaseBegin("TestRESTReportSubReqAndSubDelOk")
5334         const subReqCount int = 1
5335         testIndex := 1
5336         RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
5337 }
5338
5339 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5340         xapp.Logger.Debug("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
5341
5342         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5343                 Counter{cRestSubReqFromXapp, 1},
5344                 Counter{cRestSubRespToXapp, 1},
5345                 Counter{cSubReqToE2, uint64(subReqCount)},
5346                 Counter{cSubRespFromE2, uint64(subReqCount)},
5347                 Counter{cRestSubNotifToXapp, 1},
5348                 Counter{cRestSubDelReqFromXapp, 1},
5349                 Counter{cRestSubDelRespToXapp, 1},
5350                 Counter{cSubDelReqToE2, uint64(subReqCount)},
5351                 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5352         })
5353
5354         // Req
5355         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5356         restSubId := xappConn1.SendRESTSubsReq(t, params)
5357
5358         var e2SubsId []uint32
5359         for i := 0; i < subReqCount; i++ {
5360                 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5361                 xappConn1.ExpectRESTNotification(t, restSubId)
5362
5363                 e2termConn1.SendSubsResp(t, crereq, cremsg)
5364                 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5365                 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5366                 e2SubsId = append(e2SubsId, instanceId)
5367                 resp, _ := xapp.Subscription.QuerySubscriptions()
5368                 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
5369                 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
5370                 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
5371
5372         }
5373
5374         // Del
5375         xappConn1.SendRESTSubsDelReq(t, &restSubId)
5376
5377         for i := 0; i < subReqCount; i++ {
5378                 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5379                 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5380         }
5381
5382         // Wait that subs is cleaned
5383         for i := 0; i < subReqCount; i++ {
5384                 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5385         }
5386
5387         xappConn1.TestMsgChanEmpty(t)
5388         e2termConn1.TestMsgChanEmpty(t)
5389         mainCtrl.wait_registry_empty(t, 10)
5390         mainCtrl.VerifyAllClean(t)
5391         mainCtrl.VerifyCounterValues(t)
5392 }
5393
5394 /*
5395 func TestRESTPolicySubReqAndSubDelOk(t *testing.T) {  //Was in comments already. Next case is not run!
5396         CaseBegin("TestRESTPolicySubReqAndSubDelOk")
5397
5398         subReqCount := 2
5399         testIndex := 1
5400         RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5401
5402         subReqCount = 19
5403         testIndex = 2
5404         RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5405 }
5406 */
5407 func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5408         xapp.Logger.Debug("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
5409
5410         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5411                 Counter{cRestSubReqFromXapp, 1},
5412                 Counter{cRestSubRespToXapp, 1},
5413                 Counter{cSubReqToE2, uint64(subReqCount)},
5414                 Counter{cSubRespFromE2, uint64(subReqCount)},
5415                 Counter{cRestSubNotifToXapp, 1},
5416                 Counter{cRestSubDelReqFromXapp, 1},
5417                 Counter{cRestSubDelRespToXapp, 1},
5418                 Counter{cSubDelReqToE2, uint64(subReqCount)},
5419                 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5420         })
5421
5422         // Req
5423         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5424         restSubId := xappConn1.SendRESTSubsReq(t, params)
5425
5426         var e2SubsId []uint32
5427         for i := 0; i < subReqCount; i++ {
5428                 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5429                 xappConn1.ExpectRESTNotification(t, restSubId)
5430                 e2termConn1.SendSubsResp(t, crereq, cremsg)
5431                 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5432                 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5433                 e2SubsId = append(e2SubsId, instanceId)
5434         }
5435
5436         // Del
5437         xappConn1.SendRESTSubsDelReq(t, &restSubId)
5438
5439         for i := 0; i < subReqCount; i++ {
5440                 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5441                 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5442         }
5443
5444         // Wait that subs is cleaned
5445         for i := 0; i < subReqCount; i++ {
5446                 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5447         }
5448         xappConn1.TestMsgChanEmpty(t)
5449         e2termConn1.TestMsgChanEmpty(t)
5450         mainCtrl.wait_registry_empty(t, 10)
5451         mainCtrl.VerifyAllClean(t)
5452         mainCtrl.VerifyCounterValues(t)
5453 }
5454
5455 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
5456
5457         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5458                 Counter{cRestSubReqFromXapp, 1},
5459                 Counter{cRestSubRespToXapp, 1},
5460                 Counter{cSubReqToE2, 2},
5461                 Counter{cSubRespFromE2, 2},
5462                 Counter{cRestSubNotifToXapp, 2},
5463                 Counter{cRestSubDelReqFromXapp, 1},
5464                 Counter{cSubDelReqToE2, 2},
5465                 Counter{cSubDelRespFromE2, 2},
5466                 Counter{cRestSubDelRespToXapp, 1},
5467         })
5468
5469         const subReqCount int = 2
5470
5471         // Req
5472         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5473         restSubId := xappConn1.SendRESTSubsReq(t, params)
5474         e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5475
5476         assert.Equal(t, len(e2SubsIds), 2)
5477
5478         // Del
5479         xappConn1.SendRESTSubsDelReq(t, &restSubId)
5480         sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5481
5482         xappConn1.TestMsgChanEmpty(t)
5483         e2termConn1.TestMsgChanEmpty(t)
5484         mainCtrl.wait_registry_empty(t, 10)
5485
5486         mainCtrl.VerifyCounterValues(t)
5487         mainCtrl.VerifyAllClean(t)
5488 }
5489 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
5490
5491         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5492                 Counter{cRestSubReqFromXapp, 1},
5493                 Counter{cRestSubRespToXapp, 1},
5494                 Counter{cSubReqToE2, 19},
5495                 Counter{cSubRespFromE2, 19},
5496                 Counter{cRestSubNotifToXapp, 19},
5497                 Counter{cRestSubDelReqFromXapp, 1},
5498                 Counter{cSubDelReqToE2, 19},
5499                 Counter{cSubDelRespFromE2, 19},
5500                 Counter{cRestSubDelRespToXapp, 1},
5501         })
5502
5503         const subReqCount int = 19
5504         // Req
5505         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5506         restSubId := xappConn1.SendRESTSubsReq(t, params)
5507         e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5508
5509         assert.Equal(t, len(e2SubsIds), 19)
5510
5511         xappConn1.SendRESTSubsDelReq(t, &restSubId)
5512         sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5513
5514         xappConn1.TestMsgChanEmpty(t)
5515         e2termConn1.TestMsgChanEmpty(t)
5516         mainCtrl.wait_registry_empty(t, 10)
5517
5518         mainCtrl.VerifyCounterValues(t)
5519         mainCtrl.VerifyAllClean(t)
5520 }
5521
5522 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
5523
5524         subReqCount := 2
5525
5526         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5527                 Counter{cRestSubReqFromXapp, 1},
5528                 Counter{cRestSubRespToXapp, 1},
5529                 Counter{cSubReqToE2, uint64(subReqCount)},
5530                 Counter{cSubRespFromE2, uint64(subReqCount)},
5531                 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5532                 Counter{cRestSubDelReqFromXapp, 1},
5533                 Counter{cSubDelReqToE2, uint64(subReqCount)},
5534                 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5535                 Counter{cRestSubDelRespToXapp, 1},
5536         })
5537
5538         // Req
5539         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5540         restSubId := xappConn1.SendRESTSubsReq(t, params)
5541         e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5542
5543         assert.Equal(t, len(e2SubsIds), subReqCount)
5544
5545         // Del
5546         xappConn1.SendRESTSubsDelReq(t, &restSubId)
5547         sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5548
5549         xappConn1.TestMsgChanEmpty(t)
5550         e2termConn1.TestMsgChanEmpty(t)
5551         mainCtrl.wait_registry_empty(t, 10)
5552
5553         mainCtrl.VerifyCounterValues(t)
5554         mainCtrl.VerifyAllClean(t)
5555 }
5556
5557 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
5558
5559         subReqCount := 2
5560
5561         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5562                 Counter{cRestSubReqFromXapp, 1},
5563                 Counter{cRestSubRespToXapp, 1},
5564                 Counter{cSubReqToE2, uint64(subReqCount)},
5565                 Counter{cSubRespFromE2, uint64(subReqCount)},
5566                 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5567                 Counter{cRestSubDelReqFromXapp, 1},
5568                 Counter{cSubDelReqToE2, uint64(subReqCount)},
5569                 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5570                 Counter{cRestSubDelRespToXapp, 1},
5571         })
5572
5573         // Req
5574         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5575         restSubId := xappConn1.SendRESTSubsReq(t, params)
5576         e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5577
5578         assert.Equal(t, len(e2SubsIds), subReqCount)
5579
5580         // Del
5581         xappConn1.SendRESTSubsDelReq(t, &restSubId)
5582         sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5583
5584         xappConn1.TestMsgChanEmpty(t)
5585         e2termConn1.TestMsgChanEmpty(t)
5586         mainCtrl.wait_registry_empty(t, 10)
5587
5588         mainCtrl.VerifyCounterValues(t)
5589         mainCtrl.VerifyAllClean(t)
5590 }
5591
5592 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
5593
5594         subReqCount := 19
5595
5596         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5597                 Counter{cRestSubReqFromXapp, 1},
5598                 Counter{cRestSubRespToXapp, 1},
5599                 Counter{cSubReqToE2, uint64(subReqCount)},
5600                 Counter{cSubRespFromE2, uint64(subReqCount)},
5601                 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5602                 Counter{cRestSubDelReqFromXapp, 1},
5603                 Counter{cSubDelReqToE2, uint64(subReqCount)},
5604                 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5605                 Counter{cRestSubDelRespToXapp, 1},
5606         })
5607
5608         // Req
5609         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5610         restSubId := xappConn1.SendRESTSubsReq(t, params)
5611         e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5612
5613         assert.Equal(t, len(e2SubsIds), subReqCount)
5614
5615         // Del
5616         xappConn1.SendRESTSubsDelReq(t, &restSubId)
5617         sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5618
5619         xappConn1.TestMsgChanEmpty(t)
5620         e2termConn1.TestMsgChanEmpty(t)
5621         mainCtrl.wait_registry_empty(t, 10)
5622
5623         mainCtrl.VerifyCounterValues(t)
5624         mainCtrl.VerifyAllClean(t)
5625 }
5626
5627 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
5628         CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
5629
5630         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5631                 Counter{cRestSubReqFromXapp, 2},
5632                 Counter{cRestSubRespToXapp, 2},
5633                 Counter{cSubReqToE2, 2},
5634                 Counter{cSubRespFromE2, 2},
5635                 Counter{cRestSubNotifToXapp, 2},
5636                 Counter{cRestSubDelReqFromXapp, 2},
5637                 Counter{cSubDelReqToE2, 2},
5638                 Counter{cSubDelRespFromE2, 2},
5639                 Counter{cRestSubDelRespToXapp, 2},
5640         })
5641
5642         // Req1
5643         var params *teststube2ap.RESTSubsReqParams = nil
5644
5645         //Subs Create
5646         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5647         xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5648
5649         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5650
5651         // Req2
5652         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5653         params.SetMeid("RAN_NAME_1")
5654         eventTriggerDefinition := []int64{1234, 1}
5655         params.SetSubEventTriggerDefinition(eventTriggerDefinition)
5656
5657         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5658         xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5659         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5660         xappConn2.ExpectRESTNotification(t, restSubId2)
5661         e2termConn1.SendSubsResp(t, crereq, cremsg)
5662         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5663
5664         deleteXapp1Subscription(t, &restSubId1)
5665         deleteXapp2Subscription(t, &restSubId2)
5666
5667         waitSubsCleanup(t, e2SubsId1, 10)
5668         waitSubsCleanup(t, e2SubsId2, 10)
5669
5670         mainCtrl.VerifyCounterValues(t)
5671         mainCtrl.VerifyAllClean(t)
5672 }
5673
5674 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
5675         CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
5676
5677         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5678                 Counter{cRestSubReqFromXapp, 2},
5679                 Counter{cRestSubRespToXapp, 2},
5680                 Counter{cSubReqToE2, 2},
5681                 Counter{cSubRespFromE2, 2},
5682                 Counter{cRestSubNotifToXapp, 2},
5683                 Counter{cRestSubDelReqFromXapp, 2},
5684                 Counter{cSubDelReqToE2, 2},
5685                 Counter{cSubDelRespFromE2, 2},
5686                 Counter{cRestSubDelRespToXapp, 2},
5687         })
5688
5689         // Req1
5690         var params *teststube2ap.RESTSubsReqParams = nil
5691
5692         //Subs Create
5693         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5694         xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5695
5696         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5697
5698         // Req2
5699         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5700         params.SetMeid("RAN_NAME_1")
5701
5702         actionId := int64(1)
5703         actionType := "report"
5704         actionDefinition := []int64{5678, 1}
5705         subsequestActionType := "continue"
5706         timeToWait := "w10ms"
5707         params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
5708
5709         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5710         xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5711         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5712         xappConn2.ExpectRESTNotification(t, restSubId2)
5713         e2termConn1.SendSubsResp(t, crereq, cremsg)
5714         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5715
5716         deleteXapp1Subscription(t, &restSubId1)
5717         deleteXapp2Subscription(t, &restSubId2)
5718
5719         waitSubsCleanup(t, e2SubsId1, 10)
5720         waitSubsCleanup(t, e2SubsId2, 10)
5721
5722         mainCtrl.VerifyCounterValues(t)
5723         mainCtrl.VerifyAllClean(t)
5724 }
5725
5726 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
5727         CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
5728
5729         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5730                 Counter{cRestSubReqFromXapp, 2},
5731                 Counter{cRestSubRespToXapp, 2},
5732                 Counter{cSubReqToE2, 2},
5733                 Counter{cSubRespFromE2, 2},
5734                 Counter{cRestSubNotifToXapp, 2},
5735                 Counter{cRestSubDelReqFromXapp, 2},
5736                 Counter{cSubDelReqToE2, 2},
5737                 Counter{cSubDelRespFromE2, 2},
5738                 Counter{cRestSubDelRespToXapp, 2},
5739         })
5740
5741         // Req1
5742         var params *teststube2ap.RESTSubsReqParams = nil
5743
5744         //Subs Create
5745         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5746         xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5747
5748         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5749
5750         // Req2
5751         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5752         params.SetMeid("RAN_NAME_1")
5753         params.SetSubActionIDs(int64(2))
5754
5755         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5756         xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5757         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5758         xappConn2.ExpectRESTNotification(t, restSubId2)
5759         e2termConn1.SendSubsResp(t, crereq, cremsg)
5760         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5761
5762         deleteXapp1Subscription(t, &restSubId1)
5763         deleteXapp2Subscription(t, &restSubId2)
5764
5765         waitSubsCleanup(t, e2SubsId1, 10)
5766         waitSubsCleanup(t, e2SubsId2, 10)
5767
5768         mainCtrl.VerifyCounterValues(t)
5769         mainCtrl.VerifyAllClean(t)
5770 }
5771
5772 func TestRESTSubReqDiffActionType(t *testing.T) {
5773         CaseBegin("TestRESTSubReqDiffActionType")
5774
5775         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5776                 Counter{cRestSubReqFromXapp, 2},
5777                 Counter{cRestSubRespToXapp, 2},
5778                 Counter{cSubReqToE2, 2},
5779                 Counter{cSubRespFromE2, 2},
5780                 Counter{cRestSubNotifToXapp, 2},
5781                 Counter{cRestSubDelReqFromXapp, 2},
5782                 Counter{cSubDelReqToE2, 2},
5783                 Counter{cSubDelRespFromE2, 2},
5784                 Counter{cRestSubDelRespToXapp, 2},
5785         })
5786
5787         const e2Timeout int64 = 2
5788         const e2RetryCount int64 = 2
5789         const routingNeeded bool = true
5790
5791         // Req1
5792         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5793         params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5794
5795         //Subs Create
5796         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5797         xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5798
5799         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5800
5801         // Req2
5802         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5803         params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5804         params.SetMeid("RAN_NAME_1")
5805
5806         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5807         xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5808         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5809         xappConn2.ExpectRESTNotification(t, restSubId2)
5810         e2termConn1.SendSubsResp(t, crereq, cremsg)
5811         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5812
5813         deleteXapp1Subscription(t, &restSubId1)
5814         deleteXapp2Subscription(t, &restSubId2)
5815
5816         waitSubsCleanup(t, e2SubsId1, 10)
5817         waitSubsCleanup(t, e2SubsId2, 10)
5818
5819         mainCtrl.VerifyCounterValues(t)
5820         mainCtrl.VerifyAllClean(t)
5821 }
5822
5823 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
5824         CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
5825
5826         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5827                 Counter{cRestSubReqFromXapp, 2},
5828                 Counter{cRestSubRespToXapp, 2},
5829                 Counter{cSubReqToE2, 2},
5830                 Counter{cSubRespFromE2, 2},
5831                 Counter{cRestSubNotifToXapp, 2},
5832                 Counter{cRestSubDelReqFromXapp, 2},
5833                 Counter{cSubDelReqToE2, 2},
5834                 Counter{cSubDelRespFromE2, 2},
5835                 Counter{cRestSubDelRespToXapp, 2},
5836         })
5837
5838         const e2Timeout int64 = 2
5839         const e2RetryCount int64 = 2
5840         const routingNeeded bool = true
5841
5842         // Req1
5843         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5844         params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5845
5846         //Subs Create
5847         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5848         xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5849
5850         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5851
5852         // Req2
5853         params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
5854         params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5855         params.SetMeid("RAN_NAME_1")
5856
5857         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5858         xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5859         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5860         xappConn2.ExpectRESTNotification(t, restSubId2)
5861         e2termConn1.SendSubsResp(t, crereq, cremsg)
5862         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5863
5864         deleteXapp1Subscription(t, &restSubId1)
5865         deleteXapp2Subscription(t, &restSubId2)
5866
5867         waitSubsCleanup(t, e2SubsId1, 10)
5868         waitSubsCleanup(t, e2SubsId2, 10)
5869
5870         mainCtrl.VerifyCounterValues(t)
5871         mainCtrl.VerifyAllClean(t)
5872 }
5873
5874 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
5875         CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
5876
5877         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5878                 Counter{cRestSubReqFromXapp, 2},
5879                 Counter{cRestSubRespToXapp, 2},
5880                 Counter{cSubReqToE2, 2},
5881                 Counter{cSubRespFromE2, 2},
5882                 Counter{cRestSubNotifToXapp, 2},
5883                 Counter{cRestSubDelReqFromXapp, 2},
5884                 Counter{cSubDelReqToE2, 2},
5885                 Counter{cSubDelRespFromE2, 2},
5886                 Counter{cRestSubDelRespToXapp, 2},
5887         })
5888
5889         // Req1
5890         var params *teststube2ap.RESTSubsReqParams = nil
5891
5892         //Subs Create
5893         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5894         xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5895
5896         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5897
5898         // Req2
5899         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5900         params.SetMeid("RAN_NAME_1")
5901         actionDefinition := []int64{5678, 1}
5902         params.SetSubActionDefinition(actionDefinition)
5903
5904         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5905         xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5906         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5907         xappConn2.ExpectRESTNotification(t, restSubId2)
5908         e2termConn1.SendSubsResp(t, crereq, cremsg)
5909         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5910
5911         deleteXapp1Subscription(t, &restSubId1)
5912         deleteXapp2Subscription(t, &restSubId2)
5913
5914         waitSubsCleanup(t, e2SubsId1, 10)
5915         waitSubsCleanup(t, e2SubsId2, 10)
5916
5917         mainCtrl.VerifyCounterValues(t)
5918         mainCtrl.VerifyAllClean(t)
5919 }
5920
5921 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
5922         CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
5923
5924         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5925                 Counter{cRestSubReqFromXapp, 2},
5926                 Counter{cRestSubRespToXapp, 2},
5927                 Counter{cSubReqToE2, 2},
5928                 Counter{cSubRespFromE2, 2},
5929                 Counter{cRestSubNotifToXapp, 2},
5930                 Counter{cRestSubDelReqFromXapp, 2},
5931                 Counter{cSubDelReqToE2, 2},
5932                 Counter{cSubDelRespFromE2, 2},
5933                 Counter{cRestSubDelRespToXapp, 2},
5934         })
5935
5936         // Req1
5937         var params *teststube2ap.RESTSubsReqParams = nil
5938
5939         //Subs Create
5940         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5941         xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5942
5943         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5944
5945         // Req2
5946         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5947         params.SetMeid("RAN_NAME_1")
5948         actionDefinition := []int64{56782}
5949         params.SetSubActionDefinition(actionDefinition)
5950
5951         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5952         xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5953         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5954         xappConn2.ExpectRESTNotification(t, restSubId2)
5955         e2termConn1.SendSubsResp(t, crereq, cremsg)
5956         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5957
5958         deleteXapp1Subscription(t, &restSubId1)
5959         deleteXapp2Subscription(t, &restSubId2)
5960
5961         waitSubsCleanup(t, e2SubsId1, 10)
5962         waitSubsCleanup(t, e2SubsId2, 10)
5963
5964         mainCtrl.VerifyCounterValues(t)
5965         mainCtrl.VerifyAllClean(t)
5966 }
5967
5968 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
5969         CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
5970
5971         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5972                 Counter{cRestSubReqFromXapp, 2},
5973                 Counter{cRestSubRespToXapp, 2},
5974                 Counter{cSubReqToE2, 2},
5975                 Counter{cSubRespFromE2, 2},
5976                 Counter{cRestSubNotifToXapp, 2},
5977                 Counter{cRestSubDelReqFromXapp, 2},
5978                 Counter{cSubDelReqToE2, 2},
5979                 Counter{cSubDelRespFromE2, 2},
5980                 Counter{cRestSubDelRespToXapp, 2},
5981         })
5982
5983         // Req1
5984         var params *teststube2ap.RESTSubsReqParams = nil
5985
5986         //Subs Create
5987         restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5988         xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5989
5990         queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5991
5992         // Req2
5993         params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5994         params.SetMeid("RAN_NAME_1")
5995         params.SetTimeToWait("w200ms")
5996         restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5997         xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5998         crereq, cremsg := e2termConn1.RecvSubsReq(t)
5999         xappConn2.ExpectRESTNotification(t, restSubId2)
6000         e2termConn1.SendSubsResp(t, crereq, cremsg)
6001         e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
6002
6003         deleteXapp1Subscription(t, &restSubId1)
6004         deleteXapp2Subscription(t, &restSubId2)
6005
6006         waitSubsCleanup(t, e2SubsId1, 10)
6007         waitSubsCleanup(t, e2SubsId2, 10)
6008
6009         mainCtrl.VerifyCounterValues(t)
6010         mainCtrl.VerifyAllClean(t)
6011 }
6012
6013 //-----------------------------------------------------------------------------
6014 // TestRESTUnpackSubscriptionResponseDecodeFail
6015 //
6016 //   stub                             stub
6017 // +-------+        +---------+    +---------+
6018 // | xapp  |        | submgr  |    | e2term  |
6019 // +-------+        +---------+    +---------+
6020 //     |                 |              |
6021 //     | RestSubReq      |              |
6022 //     |---------------->|              |
6023 //     |                 |              |
6024 //     |     RESTSubResp |              |
6025 //     |<----------------|              |
6026 //     |                 |              |
6027 //     |                 | SubReq       |
6028 //     |                 |------------->|
6029 //     |                 |              |
6030 //     |                 |      SubResp | ASN.1 decode fails
6031 //     |                 |<-------------| Decode failed. More data needed. This will result timer expiry and resending
6032 //     |                 |              |
6033 //     |                 | SubReq       |
6034 //     |                 |------------->|
6035 //     |                 |              |
6036 //     |                 |      SubFail | Duplicated action
6037 //     |                 |<-------------|
6038 //     | RESTNotif (fail)|              |
6039 //     |<----------------|              |
6040 //     |                 |              |
6041 //     |           [SUBS DELETE]        |
6042 //     |                 |              |
6043 //
6044 //-----------------------------------------------------------------------------
6045
6046 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
6047         xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
6048
6049         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6050                 Counter{cRestSubReqFromXapp, 1},
6051                 Counter{cRestSubRespToXapp, 1},
6052                 Counter{cSubReqToE2, 1},
6053                 Counter{cSubReqTimerExpiry, 1},
6054                 Counter{cSubReReqToE2, 1},
6055                 Counter{cSubRespFromE2, 1},
6056                 Counter{cSubFailFromE2, 1},
6057                 Counter{cRestSubFailNotifToXapp, 1},
6058                 Counter{cRestSubDelReqFromXapp, 1},
6059                 Counter{cRestSubDelRespToXapp, 1},
6060         })
6061
6062         const subReqCount int = 1
6063
6064         // Req
6065         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6066         restSubId := xappConn1.SendRESTSubsReq(t, params)
6067
6068         crereq, cremsg := e2termConn1.RecvSubsReq(t)
6069         // Decode of this response fails which will result resending original request
6070         e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
6071
6072         _, cremsg = e2termConn1.RecvSubsReq(t)
6073
6074         xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6075
6076         // Subscription already created in E2 Node.
6077         fparams := &teststube2ap.E2StubSubsFailParams{}
6078         fparams.Set(crereq)
6079         fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6080         e2termConn1.SendSubsFail(t, fparams, cremsg)
6081
6082         instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6083         xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6084
6085         xappConn1.SendRESTSubsDelReq(t, &restSubId)
6086
6087         // Wait that subs is cleaned
6088         mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6089
6090         xappConn1.TestMsgChanEmpty(t)
6091         e2termConn1.TestMsgChanEmpty(t)
6092         mainCtrl.wait_registry_empty(t, 10)
6093         mainCtrl.VerifyAllClean(t)
6094         mainCtrl.VerifyCounterValues(t)
6095 }
6096
6097 //-----------------------------------------------------------------------------
6098 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
6099 //
6100 //   stub                             stub
6101 // +-------+        +---------+    +---------+
6102 // | xapp  |        | submgr  |    | e2term  |
6103 // +-------+        +---------+    +---------+
6104 //     |                 |              |
6105 //     | RestSubReq      |              |
6106 //     |---------------->|              |
6107 //     |                 |              |
6108 //     |     RESTSubResp |              |
6109 //     |<----------------|              |
6110 //     |                 |              |
6111 //     |                 | SubReq       |
6112 //     |                 |------------->|
6113 //     |                 |              |
6114 //     |                 |      SubResp | Unknown instanceId
6115 //     |                 |<-------------| No valid subscription found with subIds [0]
6116 //     |                 |              |
6117 //     |                 | SubReq       |
6118 //     |                 |------------->|
6119 //     |                 |              |
6120 //     |                 |      SubFail | Duplicated action
6121 //     |                 |<-------------| No valid subscription found with subIds [0]
6122 //     | RESTNotif (fail)|              |
6123 //     |<----------------|              |
6124 //     |                 | SubDelReq    |
6125 //     |                 |------------->|
6126 //     |                 |              |
6127 //     |                 |   SubDelResp |
6128 //     |                 |<-------------|
6129 //     |                 |              |
6130 //     |           [SUBS DELETE]        |
6131 //     |                 |              |
6132 //
6133 //-----------------------------------------------------------------------------
6134
6135 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
6136         xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
6137
6138         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6139                 Counter{cRestSubReqFromXapp, 1},
6140                 Counter{cRestSubRespToXapp, 1},
6141                 Counter{cSubReqToE2, 1},
6142                 Counter{cSubReqTimerExpiry, 2},
6143                 Counter{cSubReReqToE2, 1},
6144                 Counter{cSubRespFromE2, 1},
6145                 Counter{cSubFailFromE2, 1},
6146                 Counter{cRestSubFailNotifToXapp, 1},
6147                 Counter{cRestSubDelReqFromXapp, 1},
6148                 Counter{cRestSubDelRespToXapp, 1},
6149                 Counter{cSubDelReqToE2, 1},
6150                 Counter{cSubDelRespFromE2, 1},
6151         })
6152
6153         const subReqCount int = 1
6154
6155         // Req
6156         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6157         restSubId := xappConn1.SendRESTSubsReq(t, params)
6158
6159         crereq, cremsg := e2termConn1.RecvSubsReq(t)
6160
6161         // Unknown instanceId 0 in this response which will result resending original request
6162         orgInstanceId := crereq.RequestId.InstanceId
6163         crereq.RequestId.InstanceId = 0
6164         e2termConn1.SendSubsResp(t, crereq, cremsg)
6165
6166         _, cremsg = e2termConn1.RecvSubsReq(t)
6167
6168         xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6169
6170         // Subscription already created in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
6171         fparams := &teststube2ap.E2StubSubsFailParams{}
6172         fparams.Set(crereq)
6173         fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6174         e2termConn1.SendSubsFail(t, fparams, cremsg)
6175
6176         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6177         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6178
6179         instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6180         xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6181
6182         xappConn1.SendRESTSubsDelReq(t, &restSubId)
6183
6184         // Wait that subs is cleaned
6185         mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
6186
6187         xappConn1.TestMsgChanEmpty(t)
6188         e2termConn1.TestMsgChanEmpty(t)
6189         mainCtrl.wait_registry_empty(t, 10)
6190         mainCtrl.VerifyAllClean(t)
6191         mainCtrl.VerifyCounterValues(t)
6192 }
6193
6194 //-----------------------------------------------------------------------------
6195 // TestRESTUnpackSubscriptionResponseNoTransaction
6196 //
6197 //   stub                             stub
6198 // +-------+        +---------+    +---------+
6199 // | xapp  |        | submgr  |    | e2term  |
6200 // +-------+        +---------+    +---------+
6201 //     |                 |              |
6202 //     | RestSubReq      |              |
6203 //     |---------------->|              |
6204 //     |                 |              |
6205 //     |     RESTSubResp |              |
6206 //     |<----------------|              |
6207 //     |                 |              |
6208 //     |                 | SubReq       |
6209 //     |                 |------------->|
6210 //     |                 |              |
6211 //     |                 |      SubResp | No transaction for the response
6212 //     |                 |<-------------| Ongoing transaction not found. This will result timer expiry and resending
6213 //     |                 |              |
6214 //     |                 | SubReq       |
6215 //     |                 |------------->|
6216 //     |                 |              |
6217 //     |                 |      SubFail | Duplicated action
6218 //     |                 |<-------------|Ongoing transaction not found. This will result timer expiry and sending delete
6219 //     | RESTNotif (fail)|              |
6220 //     |<----------------|              |
6221 //     |                 | SubDelReq    |
6222 //     |                 |------------->|
6223 //     |                 |              |
6224 //     |                 |   SubDelResp |
6225 //     |                 |<-------------| Ongoing transaction not found. This will result timer expiry and resending
6226 //     |                 |              |
6227 //     |                 | SubDelReq    |
6228 //     |                 |------------->|
6229 //     |                 |              |
6230 //     |                 |   SubDelResp |
6231 //     |                 |<-------------| Ongoing transaction not found.
6232 //     |                 |              |
6233 //     |           [SUBS DELETE]        |
6234 //     |                 |              |
6235 //
6236 //-----------------------------------------------------------------------------
6237 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
6238         xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
6239
6240         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6241                 Counter{cRestSubReqFromXapp, 1},
6242                 Counter{cRestSubRespToXapp, 1},
6243                 Counter{cSubReqToE2, 1},
6244                 Counter{cSubReqTimerExpiry, 2},
6245                 Counter{cSubReReqToE2, 1},
6246                 Counter{cSubRespFromE2, 1},
6247                 Counter{cSubFailFromE2, 1},
6248                 Counter{cRestSubFailNotifToXapp, 1},
6249                 Counter{cRestSubDelReqFromXapp, 1},
6250                 Counter{cRestSubDelRespToXapp, 1},
6251                 Counter{cSubDelReqToE2, 1},
6252                 Counter{cSubDelReqTimerExpiry, 2},
6253                 Counter{cSubDelReReqToE2, 1},
6254                 Counter{cSubDelRespFromE2, 2},
6255         })
6256
6257         const subReqCount int = 1
6258
6259         // Req
6260         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6261         restSubId := xappConn1.SendRESTSubsReq(t, params)
6262
6263         crereq, cremsg := e2termConn1.RecvSubsReq(t)
6264
6265         mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6266         // No transaction exist for this response which will result resending original request
6267         e2termConn1.SendSubsResp(t, crereq, cremsg)
6268
6269         _, cremsg = e2termConn1.RecvSubsReq(t)
6270
6271         xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6272
6273         // Subscription already created in E2 Node.
6274         fparams := &teststube2ap.E2StubSubsFailParams{}
6275         fparams.Set(crereq)
6276         fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6277         e2termConn1.SendSubsFail(t, fparams, cremsg)
6278
6279         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6280         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6281
6282         // Resending happens because there no transaction
6283         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6284         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6285
6286         instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6287         xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6288
6289         xappConn1.SendRESTSubsDelReq(t, &restSubId)
6290
6291         // Wait that subs is cleaned
6292         mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6293
6294         xappConn1.TestMsgChanEmpty(t)
6295         e2termConn1.TestMsgChanEmpty(t)
6296         mainCtrl.wait_registry_empty(t, 10)
6297         mainCtrl.VerifyAllClean(t)
6298         mainCtrl.VerifyCounterValues(t)
6299 }
6300
6301 //-----------------------------------------------------------------------------
6302 // TestRESTUnpackSubscriptionFailureDecodeFail
6303 //
6304 //   stub                             stub
6305 // +-------+        +---------+    +---------+
6306 // | xapp  |        | submgr  |    | e2term  |
6307 // +-------+        +---------+    +---------+
6308 //     |                 |              |
6309 //     | RestSubReq      |              |
6310 //     |---------------->|              |
6311 //     |                 |              |
6312 //     |     RESTSubResp |              |
6313 //     |<----------------|              |
6314 //     |                 |              |
6315 //     |                 | SubReq       |
6316 //     |                 |------------->|
6317 //     |                 |              |
6318 //     |                 |      SubFail | ASN.1 decode fails
6319 //     |                 |<-------------| Decode failed. More data needed. This will result timer expiry and resending
6320 //     |                 |              |
6321 //     |                 | SubReq       |
6322 //     |                 |------------->|
6323 //     |                 |              |
6324 //     |                 |      SubFail | Duplicated action
6325 //     |                 |<-------------|
6326 //     | RESTNotif (fail)|              |
6327 //     |<----------------|              |
6328 //     |                 |              |
6329 //     |           [SUBS DELETE]        |
6330 //     |                 |              |
6331 //
6332 //-----------------------------------------------------------------------------
6333 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
6334         xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
6335
6336         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6337                 Counter{cRestSubReqFromXapp, 1},
6338                 Counter{cRestSubRespToXapp, 1},
6339                 Counter{cSubReqToE2, 1},
6340                 Counter{cSubReqTimerExpiry, 1},
6341                 Counter{cSubReReqToE2, 1},
6342                 Counter{cSubFailFromE2, 2},
6343                 Counter{cRestSubFailNotifToXapp, 1},
6344                 Counter{cRestSubDelReqFromXapp, 1},
6345                 Counter{cRestSubDelRespToXapp, 1},
6346         })
6347
6348         const subReqCount int = 1
6349
6350         // Req
6351         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6352         restSubId := xappConn1.SendRESTSubsReq(t, params)
6353
6354         crereq, cremsg := e2termConn1.RecvSubsReq(t)
6355
6356         // Decode of this response fails which will result resending original request
6357         e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
6358
6359         _, cremsg = e2termConn1.RecvSubsReq(t)
6360
6361         xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6362
6363         // Subscription already created in E2 Node.
6364         fparams := &teststube2ap.E2StubSubsFailParams{}
6365         fparams.Set(crereq)
6366         fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6367         e2termConn1.SendSubsFail(t, fparams, cremsg)
6368
6369         instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6370         xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6371
6372         xappConn1.SendRESTSubsDelReq(t, &restSubId)
6373
6374         // Wait that subs is cleaned
6375         mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6376
6377         xappConn1.TestMsgChanEmpty(t)
6378         e2termConn1.TestMsgChanEmpty(t)
6379         mainCtrl.wait_registry_empty(t, 10)
6380         mainCtrl.VerifyAllClean(t)
6381         mainCtrl.VerifyCounterValues(t)
6382 }
6383
6384 //-----------------------------------------------------------------------------
6385 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
6386 //
6387 //   stub                             stub
6388 // +-------+        +---------+    +---------+
6389 // | xapp  |        | submgr  |    | e2term  |
6390 // +-------+        +---------+    +---------+
6391 //     |                 |              |
6392 //     | RestSubReq      |              |
6393 //     |---------------->|              |
6394 //     |                 |              |
6395 //     |     RESTSubResp |              |
6396 //     |<----------------|              |
6397 //     |                 |              |
6398 //     |                 | SubReq       |
6399 //     |                 |------------->|
6400 //     |                 |              |
6401 //     |                 |      SubFail | Unknown instanceId
6402 //     |                 |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
6403 //     |                 |              |
6404 //     |                 | SubReq       |
6405 //     |                 |------------->|
6406 //     |                 |              |
6407 //     |                 |      SubFail | Duplicated action
6408 //     |                 |<-------------|No valid subscription found with subIds [0]. This will result timer expiry and sending delete
6409 //     | RESTNotif (fail)|              |
6410 //     |<----------------|              |
6411 //     |                 | SubDelReq    |
6412 //     |                 |------------->|
6413 //     |                 |              |
6414 //     |                 |   SubDelResp |
6415 //     |                 |<-------------|
6416 //     |                 |              |
6417 //     |           [SUBS DELETE]        |
6418 //     |                 |              |
6419 //
6420 //-----------------------------------------------------------------------------
6421 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
6422         xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
6423         const subReqCount int = 1
6424
6425         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6426                 Counter{cRestSubReqFromXapp, 1},
6427                 Counter{cRestSubRespToXapp, 1},
6428                 Counter{cSubReqToE2, 1},
6429                 Counter{cSubReqTimerExpiry, 2},
6430                 Counter{cSubReReqToE2, 1},
6431                 Counter{cSubFailFromE2, 2},
6432                 Counter{cRestSubFailNotifToXapp, 1},
6433                 Counter{cRestSubDelReqFromXapp, 1},
6434                 Counter{cRestSubDelRespToXapp, 1},
6435                 Counter{cSubDelReqToE2, 1},
6436                 Counter{cSubDelRespFromE2, 1},
6437         })
6438
6439         // Req
6440         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6441         restSubId := xappConn1.SendRESTSubsReq(t, params)
6442
6443         crereq, cremsg := e2termConn1.RecvSubsReq(t)
6444
6445         // Unknown instanceId 0 in this response which will result resending original request
6446         fparams := &teststube2ap.E2StubSubsFailParams{}
6447         fparams.Set(crereq)
6448         fparams.Fail.RequestId.InstanceId = 0
6449         e2termConn1.SendSubsFail(t, fparams, cremsg)
6450
6451         _, cremsg = e2termConn1.RecvSubsReq(t)
6452
6453         xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6454
6455         // Subscription already created in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
6456         fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6457         e2termConn1.SendSubsFail(t, fparams, cremsg)
6458
6459         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6460         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6461
6462         instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6463         xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6464
6465         xappConn1.SendRESTSubsDelReq(t, &restSubId)
6466
6467         // Wait that subs is cleaned
6468         mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6469
6470         xappConn1.TestMsgChanEmpty(t)
6471         e2termConn1.TestMsgChanEmpty(t)
6472         mainCtrl.wait_registry_empty(t, 10)
6473         mainCtrl.VerifyAllClean(t)
6474         mainCtrl.VerifyCounterValues(t)
6475 }
6476
6477 //-----------------------------------------------------------------------------
6478 // TestRESTUnpackSubscriptionFailureNoTransaction
6479 //
6480 //   stub                             stub
6481 // +-------+        +---------+    +---------+
6482 // | xapp  |        | submgr  |    | e2term  |
6483 // +-------+        +---------+    +---------+
6484 //     |                 |              |
6485 //     | RestSubReq      |              |
6486 //     |---------------->|              |
6487 //     |                 |              |
6488 //     |     RESTSubResp |              |
6489 //     |<----------------|              |
6490 //     |                 |              |
6491 //     |                 | SubReq       |
6492 //     |                 |------------->|
6493 //     |                 |              |
6494 //     |                 |      SubFail | No transaction for the response
6495 //     |                 |<-------------| Ongoing transaction not found. This will result timer expiry and resending
6496 //     |                 |              |
6497 //     |                 | SubReq       |
6498 //     |                 |------------->|
6499 //     |                 |              |
6500 //     |                 |      SubFail | Duplicated action
6501 //     |                 |<-------------| Ongoing transaction not found. This will result timer expiry and sending delete
6502 //     | RESTNotif (fail)|              |
6503 //     |<----------------|              |
6504 //     |                 | SubDelReq    |
6505 //     |                 |------------->|
6506 //     |                 |              |
6507 //     |                 |   SubDelResp |
6508 //     |                 |<-------------| Ongoing transaction not found. This will result timer expiry and resending
6509 //     |                 |              |
6510 //     |                 | SubDelReq    |
6511 //     |                 |------------->|
6512 //     |                 |              |
6513 //     |                 |   SubDelResp |
6514 //     |                 |<-------------| Ongoing transaction not found.
6515 //     |                 |              |
6516 //     |           [SUBS DELETE]        |
6517 //     |                 |              |
6518 //
6519 //-----------------------------------------------------------------------------
6520 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
6521         xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
6522         const subReqCount int = 1
6523
6524         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6525                 Counter{cRestSubReqFromXapp, 1},
6526                 Counter{cRestSubRespToXapp, 1},
6527                 Counter{cSubReqToE2, 1},
6528                 Counter{cSubReqTimerExpiry, 2},
6529                 Counter{cSubReReqToE2, 1},
6530                 Counter{cSubFailFromE2, 2},
6531                 Counter{cRestSubFailNotifToXapp, 1},
6532                 Counter{cRestSubDelReqFromXapp, 1},
6533                 Counter{cRestSubDelRespToXapp, 1},
6534                 Counter{cSubDelReqToE2, 1},
6535                 Counter{cSubDelReqTimerExpiry, 2},
6536                 Counter{cSubDelReReqToE2, 1},
6537                 Counter{cSubDelRespFromE2, 2},
6538         })
6539
6540         // Req
6541         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6542         restSubId := xappConn1.SendRESTSubsReq(t, params)
6543
6544         crereq, cremsg := e2termConn1.RecvSubsReq(t)
6545
6546         mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6547
6548         // No transaction exist for this response which will result resending original request
6549         fparams := &teststube2ap.E2StubSubsFailParams{}
6550         fparams.Set(crereq)
6551         e2termConn1.SendSubsFail(t, fparams, cremsg)
6552
6553         _, cremsg = e2termConn1.RecvSubsReq(t)
6554
6555         xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6556
6557         // Subscription already created in E2 Node.
6558         fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6559         e2termConn1.SendSubsFail(t, fparams, cremsg)
6560
6561         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6562         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6563
6564         // Resending happens because there no transaction
6565         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6566         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6567
6568         instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6569         xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6570
6571         xappConn1.SendRESTSubsDelReq(t, &restSubId)
6572
6573         // Wait that subs is cleaned
6574         mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6575
6576         xappConn1.TestMsgChanEmpty(t)
6577         e2termConn1.TestMsgChanEmpty(t)
6578         mainCtrl.wait_registry_empty(t, 10)
6579         mainCtrl.VerifyAllClean(t)
6580         mainCtrl.VerifyCounterValues(t)
6581 }
6582
6583 //-----------------------------------------------------------------------------
6584 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
6585 //
6586 //   stub                             stub
6587 // +-------+        +---------+    +---------+
6588 // | xapp  |        | submgr  |    | e2term  |
6589 // +-------+        +---------+    +---------+
6590 //     |                 |              |
6591 //     |            [SUBS CREATE]       |
6592 //     |                 |              |
6593 //     |                 |              |
6594 //     | RESTSubDelReq   |              |
6595 //     |---------------->|              |
6596 //     |                 |              |
6597 //     |  RESTSubDelResp |              |
6598 //     |<----------------|              |
6599 //     |                 |              |
6600 //     |                 | SubDelReq    |
6601 //     |                 |------------->|
6602 //     |                 |              |
6603 //     |                 |   SubDelResp | ASN.1 decode fails.
6604 //     |                 |<-------------| Decode failed. More data needed. This will result timer expiry and resending
6605 //     |                 |              |
6606 //     |                 | SubDelReq    |
6607 //     |                 |------------->|
6608 //     |                 |              |
6609 //     |                 |   SubDelFail | Subscription does exist any more in E2 node
6610 //     |                 |<-------------|
6611 //     |                 |              |
6612 //     |           [SUBS DELETE]        |
6613 //     |                 |              |
6614 //
6615 //-----------------------------------------------------------------------------
6616 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
6617         xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail")
6618
6619         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6620                 Counter{cRestSubReqFromXapp, 1},
6621                 Counter{cRestSubRespToXapp, 1},
6622                 Counter{cSubReqToE2, 1},
6623                 Counter{cSubRespFromE2, 1},
6624                 Counter{cRestSubNotifToXapp, 1},
6625                 Counter{cRestSubDelReqFromXapp, 1},
6626                 Counter{cRestSubDelRespToXapp, 1},
6627                 Counter{cSubDelReqToE2, 1},
6628                 Counter{cSubDelReqTimerExpiry, 1},
6629                 Counter{cSubDelReReqToE2, 1},
6630                 Counter{cSubDelFailFromE2, 1},
6631                 Counter{cSubDelRespFromE2, 1},
6632         })
6633
6634         // Req
6635         var params *teststube2ap.RESTSubsReqParams = nil
6636         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6637
6638         // Del
6639         xappConn1.SendRESTSubsDelReq(t, &restSubId)
6640
6641         // E2t: Receive 1st SubsDelReq
6642         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6643
6644         // Decode of this response fails which will result resending original request
6645         e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_RESP)
6646
6647         // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6648         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6649
6650         // Subscription does not exist in in E2 Node.
6651         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6652
6653         // Wait that subs is cleaned
6654         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6655
6656         xappConn1.TestMsgChanEmpty(t)
6657         e2termConn1.TestMsgChanEmpty(t)
6658         mainCtrl.wait_registry_empty(t, 10)
6659         mainCtrl.VerifyAllClean(t)
6660         mainCtrl.VerifyCounterValues(t)
6661 }
6662
6663 //-----------------------------------------------------------------------------
6664 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
6665 //
6666 //   stub                             stub
6667 // +-------+        +---------+    +---------+
6668 // | xapp  |        | submgr  |    | e2term  |
6669 // +-------+        +---------+    +---------+
6670 //     |                 |              |
6671 //     |            [SUBS CREATE]       |
6672 //     |                 |              |
6673 //     |                 |              |
6674 //     | RESTSubDelReq   |              |
6675 //     |---------------->|              |
6676 //     |                 |              |
6677 //     |  RESTSubDelResp |              |
6678 //     |<----------------|              |
6679 //     |                 |              |
6680 //     |                 | SubDelReq    |
6681 //     |                 |------------->|
6682 //     |                 |              |
6683 //     |                 |   SubDelResp | Unknown instanceId
6684 //     |                 |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
6685 //     |                 |              |
6686 //     |                 | SubDelReq    |
6687 //     |                 |------------->|
6688 //     |                 |              |
6689 //     |                 |   SubDelFail | Subscription does exist any more in E2 node
6690 //     |                 |<-------------|
6691 //     |                 |              |
6692 //     |           [SUBS DELETE]        |
6693 //     |                 |              |
6694 //-----------------------------------------------------------------------------
6695 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
6696         xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId")
6697
6698         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6699                 Counter{cRestSubReqFromXapp, 1},
6700                 Counter{cRestSubRespToXapp, 1},
6701                 Counter{cSubReqToE2, 1},
6702                 Counter{cSubRespFromE2, 1},
6703                 Counter{cRestSubNotifToXapp, 1},
6704                 Counter{cRestSubDelReqFromXapp, 1},
6705                 Counter{cRestSubDelRespToXapp, 1},
6706                 Counter{cSubDelReqToE2, 1},
6707                 Counter{cSubDelReqTimerExpiry, 1},
6708                 Counter{cSubDelReReqToE2, 1},
6709                 Counter{cSubDelRespFromE2, 1},
6710                 Counter{cSubDelFailFromE2, 1},
6711         })
6712
6713         // Req
6714         var params *teststube2ap.RESTSubsReqParams = nil
6715         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6716
6717         // Del
6718         xappConn1.SendRESTSubsDelReq(t, &restSubId)
6719
6720         // E2t: Receive 1st SubsDelReq
6721         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6722
6723         // Unknown instanceId in this response which will result resending original request
6724         delreq.RequestId.InstanceId = 0
6725         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6726
6727         // E2t: Receive 2nd SubsDelReq
6728         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6729
6730         // Subscription does not exist in in E2 Node.
6731         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6732
6733         // Wait that subs is cleaned
6734         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6735
6736         xappConn1.TestMsgChanEmpty(t)
6737         e2termConn1.TestMsgChanEmpty(t)
6738         mainCtrl.wait_registry_empty(t, 10)
6739         mainCtrl.VerifyAllClean(t)
6740         mainCtrl.VerifyCounterValues(t)
6741 }
6742
6743 //-----------------------------------------------------------------------------
6744 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
6745 //
6746 //   stub                             stub
6747 // +-------+        +---------+    +---------+
6748 // | xapp  |        | submgr  |    | e2term  |
6749 // +-------+        +---------+    +---------+
6750 //     |                 |              |
6751 //     |            [SUBS CREATE]       |
6752 //     |                 |              |
6753 //     |                 |              |
6754 //     | RESTSubDelReq   |              |
6755 //     |---------------->|              |
6756 //     |                 |              |
6757 //     |  RESTSubDelResp |              |
6758 //     |<----------------|              |
6759 //     |                 |              |
6760 //     |                 | SubDelReq    |
6761 //     |                 |------------->|
6762 //     |                 |              |
6763 //     |                 |   SubDelResp | No transaction for the response
6764 //     |                 |<-------------| Ongoing transaction not found. This will result timer expiry and resending
6765 //     |                 |              |
6766 //     |                 | SubDelReq    |
6767 //     |                 |------------->|
6768 //     |                 |              |
6769 //     |                 |   SubDelFail | Subscription does exist any more in E2 node
6770 //     |                 |<-------------| Ongoing transaction not found. This will result timer expiry
6771 //     |                 |              |
6772 //     |           [SUBS DELETE]        |
6773 //     |                 |              |
6774 //-----------------------------------------------------------------------------
6775 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
6776         xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction")
6777
6778         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6779                 Counter{cRestSubReqFromXapp, 1},
6780                 Counter{cRestSubRespToXapp, 1},
6781                 Counter{cSubReqToE2, 1},
6782                 Counter{cSubRespFromE2, 1},
6783                 Counter{cRestSubNotifToXapp, 1},
6784                 Counter{cRestSubDelReqFromXapp, 1},
6785                 Counter{cRestSubDelRespToXapp, 1},
6786                 Counter{cSubDelReqToE2, 1},
6787                 Counter{cSubDelReqTimerExpiry, 2},
6788                 Counter{cSubDelReReqToE2, 1},
6789                 Counter{cSubDelRespFromE2, 1},
6790                 Counter{cSubDelFailFromE2, 1},
6791         })
6792
6793         // Req
6794         var params *teststube2ap.RESTSubsReqParams = nil
6795         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6796
6797         // Del
6798         xappConn1.SendRESTSubsDelReq(t, &restSubId)
6799
6800         // E2t: Receive 1st SubsDelReq
6801         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6802
6803         mainCtrl.MakeTransactionNil(t, e2SubsId)
6804
6805         // No transaction exist for this response which will result resending original request
6806         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6807
6808         // E2t: Receive 2nd SubsDelReq
6809         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6810
6811         // Subscription does not exist in in E2 Node.
6812         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6813
6814         // Wait that subs is cleaned
6815         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6816
6817         xappConn1.TestMsgChanEmpty(t)
6818         e2termConn1.TestMsgChanEmpty(t)
6819         mainCtrl.wait_registry_empty(t, 10)
6820         mainCtrl.VerifyAllClean(t)
6821         mainCtrl.VerifyCounterValues(t)
6822 }
6823
6824 //-----------------------------------------------------------------------------
6825 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
6826 //
6827 //   stub                             stub
6828 // +-------+        +---------+    +---------+
6829 // | xapp  |        | submgr  |    | e2term  |
6830 // +-------+        +---------+    +---------+
6831 //     |                 |              |
6832 //     |            [SUBS CREATE]       |
6833 //     |                 |              |
6834 //     |                 |              |
6835 //     | RESTSubDelReq   |              |
6836 //     |---------------->|              |
6837 //     |                 |              |
6838 //     |  RESTSubDelResp |              |
6839 //     |<----------------|              |
6840 //     |                 |              |
6841 //     |                 | SubDelReq    |
6842 //     |                 |------------->|
6843 //     |                 |              |
6844 //     |                 |   SubDelFail | ASN.1 decode fails
6845 //     |                 |<-------------| Decode failed. More data needed. This will result timer expiry and resending
6846 //     |                 |              |
6847 //     |                 | SubDelReq    |
6848 //     |                 |------------->|
6849 //     |                 |              |
6850 //     |                 |   SubDelFail | Subscription does exist any more in E2 node
6851 //     |                 |<-------------|
6852 //     |                 |              |
6853 //     |           [SUBS DELETE]        |
6854 //     |                 |              |
6855 //-----------------------------------------------------------------------------
6856 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
6857         xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail")
6858
6859         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6860                 Counter{cRestSubReqFromXapp, 1},
6861                 Counter{cRestSubRespToXapp, 1},
6862                 Counter{cSubReqToE2, 1},
6863                 Counter{cSubRespFromE2, 1},
6864                 Counter{cRestSubNotifToXapp, 1},
6865                 Counter{cRestSubDelReqFromXapp, 1},
6866                 Counter{cRestSubDelRespToXapp, 1},
6867                 Counter{cSubDelReqToE2, 1},
6868                 Counter{cSubDelReqTimerExpiry, 1},
6869                 Counter{cSubDelReReqToE2, 1},
6870                 Counter{cSubDelFailFromE2, 2},
6871         })
6872
6873         // Req
6874         var params *teststube2ap.RESTSubsReqParams = nil
6875         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6876
6877         // Del
6878         xappConn1.SendRESTSubsDelReq(t, &restSubId)
6879
6880         // E2t: Receive 1st SubsDelReq
6881         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6882
6883         // Decode of this response fails which will result resending original request
6884         e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
6885
6886         // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6887         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6888
6889         // Subscription does not exist in in E2 Node.
6890         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6891
6892         // Wait that subs is cleaned
6893         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6894
6895         xappConn1.TestMsgChanEmpty(t)
6896         e2termConn1.TestMsgChanEmpty(t)
6897         mainCtrl.wait_registry_empty(t, 10)
6898         mainCtrl.VerifyAllClean(t)
6899         mainCtrl.VerifyCounterValues(t)
6900 }
6901
6902 //-----------------------------------------------------------------------------
6903 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
6904 //
6905 //   stub                             stub
6906 // +-------+        +---------+    +---------+
6907 // | xapp  |        | submgr  |    | e2term  |
6908 // +-------+        +---------+    +---------+
6909 //     |                 |              |
6910 //     |            [SUBS CREATE]       |
6911 //     |                 |              |
6912 //     |                 |              |
6913 //     | RESTSubDelReq   |              |
6914 //     |---------------->|              |
6915 //     |                 |              |
6916 //     |  RESTSubDelResp |              |
6917 //     |<----------------|              |
6918 //     |                 |              |
6919 //     |                 | SubDelReq    |
6920 //     |                 |------------->|
6921 //     |                 |              |
6922 //     |                 |   SubDelFail | Unknown instanceId
6923 //     |                 |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
6924 //     |                 |              |
6925 //     |                 | SubDelReq    |
6926 //     |                 |------------->|
6927 //     |                 |              |
6928 //     |                 |   SubDelFail | Subscription does exist any more in E2 node
6929 //     |                 |<-------------| No valid subscription found with subIds [0].
6930 //     |                 |              |
6931 //     |           [SUBS DELETE]        |
6932 //     |                 |              |
6933 //-----------------------------------------------------------------------------
6934 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
6935         xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId")
6936
6937         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6938                 Counter{cRestSubReqFromXapp, 1},
6939                 Counter{cRestSubRespToXapp, 1},
6940                 Counter{cSubReqToE2, 1},
6941                 Counter{cSubRespFromE2, 1},
6942                 Counter{cRestSubNotifToXapp, 1},
6943                 Counter{cRestSubDelReqFromXapp, 1},
6944                 Counter{cRestSubDelRespToXapp, 1},
6945                 Counter{cSubDelReqToE2, 1},
6946                 Counter{cSubDelReqTimerExpiry, 1},
6947                 Counter{cSubDelReReqToE2, 1},
6948                 Counter{cSubDelFailFromE2, 2},
6949         })
6950
6951         // Req
6952         var params *teststube2ap.RESTSubsReqParams = nil
6953         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6954
6955         // Del
6956         xappConn1.SendRESTSubsDelReq(t, &restSubId)
6957
6958         // E2t: Receive 1st SubsDelReq
6959         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6960
6961         // Unknown instanceId 0 in this response which will result resending original request
6962         delreq.RequestId.InstanceId = 0
6963         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6964
6965         // E2t: Receive 2nd SubsDelReq
6966         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6967
6968         // Subscription does not exist in in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
6969         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6970
6971         // Wait that subs is cleaned
6972         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6973
6974         xappConn1.TestMsgChanEmpty(t)
6975         e2termConn1.TestMsgChanEmpty(t)
6976         mainCtrl.wait_registry_empty(t, 10)
6977         mainCtrl.VerifyAllClean(t)
6978         mainCtrl.VerifyCounterValues(t)
6979 }
6980
6981 //-----------------------------------------------------------------------------
6982 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
6983 //
6984 //   stub                             stub
6985 // +-------+        +---------+    +---------+
6986 // | xapp  |        | submgr  |    | e2term  |
6987 // +-------+        +---------+    +---------+
6988 //     |                 |              |
6989 //     |            [SUBS CREATE]       |
6990 //     |                 |              |
6991 //     |                 |              |
6992 //     | RESTSubDelReq   |              |
6993 //     |---------------->|              |
6994 //     |                 |              |
6995 //     |  RESTSubDelResp |              |
6996 //     |<----------------|              |
6997 //     |                 |              |
6998 //     |                 | SubDelReq    |
6999 //     |                 |------------->|
7000 //     |                 |              |
7001 //     |                 |   SubDelFail | No transaction for the response
7002 //     |                 |<-------------| Ongoing transaction not found. This will result timer expiry and resending
7003 //     |                 |              |
7004 //     |                 | SubDelReq    |
7005 //     |                 |------------->|
7006 //     |                 |              |
7007 //     |                 |   SubDelFail | Subscription does exist any more in E2 node
7008 //     |                 |<-------------| Ongoing transaction not found. This will result timer expiry
7009 //     |                 |              |
7010 //     |           [SUBS DELETE]        |
7011 //     |                 |              |
7012 //-----------------------------------------------------------------------------
7013 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
7014         xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction")
7015
7016         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7017                 Counter{cRestSubReqFromXapp, 1},
7018                 Counter{cRestSubRespToXapp, 1},
7019                 Counter{cSubReqToE2, 1},
7020                 Counter{cSubRespFromE2, 1},
7021                 Counter{cRestSubNotifToXapp, 1},
7022                 Counter{cRestSubDelReqFromXapp, 1},
7023                 Counter{cRestSubDelRespToXapp, 1},
7024                 Counter{cSubDelReqToE2, 1},
7025                 Counter{cSubDelReqTimerExpiry, 2},
7026                 Counter{cSubDelReReqToE2, 1},
7027                 Counter{cSubDelFailFromE2, 2},
7028         })
7029
7030         // Req
7031         var params *teststube2ap.RESTSubsReqParams = nil
7032         restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
7033
7034         // Del
7035         xappConn1.SendRESTSubsDelReq(t, &restSubId)
7036
7037         // E2t: Receive 1st SubsDelReq
7038         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7039
7040         mainCtrl.MakeTransactionNil(t, e2SubsId)
7041
7042         // No transaction exist for this response which will result resending original request
7043         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
7044
7045         // E2t: Receive 2nd SubsDelReq
7046         delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
7047
7048         // Subscription does not exist in in E2 Node.
7049         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
7050
7051         // Wait that subs is cleaned
7052         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
7053
7054         xappConn1.TestMsgChanEmpty(t)
7055         e2termConn1.TestMsgChanEmpty(t)
7056         mainCtrl.wait_registry_empty(t, 10)
7057         mainCtrl.VerifyAllClean(t)
7058         mainCtrl.VerifyCounterValues(t)
7059 }
7060
7061 //-----------------------------------------------------------------------------
7062 // TestRESTSubReqFailAsn1PackSubReqError
7063 //
7064 //   stub                             stub
7065 // +-------+        +---------+    +---------+
7066 // | xapp  |        | submgr  |    | e2term  |
7067 // +-------+        +---------+    +---------+
7068 //     |                 |              |
7069 //     | RESTSubReq      |              |
7070 //     |---------------->|              |
7071 //     |                 |              |
7072 //     |     RESTSubResp |              |
7073 //     |<----------------|              |
7074 //     |                 |              |
7075 //     |        ASN.1 encode fails      |
7076 //     |                 |              |
7077 //     |                 | SubDelReq    |
7078 //     |                 |------------->|
7079 //     |                 |              |
7080 //     |                 |  SubDelFail  |
7081 //     |                 |<-------------|
7082 //     |                 |              |
7083 //     |       RESTNotif |              |
7084 //     |       unsuccess |              |
7085 //     |<----------------|              |
7086 //     |                 |              |
7087 //     |            [SUBS DELETE]       |
7088 //     |                 |              |
7089 //
7090 //-----------------------------------------------------------------------------
7091 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
7092
7093         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7094                 Counter{cRestSubReqFromXapp, 1},
7095                 Counter{cRestSubRespToXapp, 1},
7096                 Counter{cRestSubFailNotifToXapp, 1},
7097                 Counter{cRestSubDelReqFromXapp, 1},
7098                 Counter{cRestSubDelRespToXapp, 1},
7099         })
7100
7101         const subReqCount int = 1
7102
7103         var params *teststube2ap.RESTSubsReqParams = nil
7104         params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
7105         e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
7106
7107         // Req
7108         restSubId := xappConn1.SendRESTSubsReq(t, params)
7109         xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
7110
7111         // E2t: Receive SubsDelReq
7112         xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7113
7114         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7115         xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
7116
7117         e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
7118
7119         xappConn1.SendRESTSubsDelReq(t, &restSubId)
7120
7121         // Wait that subs is cleaned
7122         waitSubsCleanup(t, e2SubsId, 10)
7123         mainCtrl.VerifyAllClean(t)
7124         mainCtrl.VerifyCounterValues(t)
7125 }
7126
7127 func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
7128         CaseBegin("TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction")
7129
7130         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7131                 Counter{cRestSubReqFromXapp, 2},
7132                 Counter{cRestSubRespToXapp, 2},
7133                 Counter{cSubReqToE2, 2},
7134                 Counter{cSubReqTimerExpiry, 1},
7135                 Counter{cSubRespFromE2, 1},
7136                 Counter{cRestSubNotifToXapp, 1},
7137                 Counter{cRestSubFailNotifToXapp, 1},
7138                 Counter{cRestSubDelReqFromXapp, 1},
7139                 Counter{cSubDelReqToE2, 1},
7140                 Counter{cSubDelRespFromE2, 1},
7141                 Counter{cRestSubDelRespToXapp, 1},
7142         })
7143
7144         const e2Timeout int64 = 1
7145         const e2RetryCount int64 = 0
7146         const routingNeeded bool = false
7147
7148         // Req1
7149         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7150         params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7151
7152         // Subs Create
7153         restSubId := xappConn1.SendRESTSubsReq(t, params)
7154         xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
7155
7156         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7157         xappConn1.ExpectRESTNotification(t, restSubId)
7158         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
7159         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7160         xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7161
7162         // Policy change
7163         params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7164         params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7165         params.SetSubscriptionID(&restSubId)
7166         params.SetTimeToWait("w200ms")
7167         restSubId = xappConn1.SendRESTSubsReq(t, params)
7168         xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
7169
7170         crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
7171         xappConn1.ExpectRESTNotification(t, restSubId)
7172         // SubsResp is missing, e2SubsId will be 0
7173         zeroE2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7174         xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", zeroE2SubsId)
7175
7176         // Del
7177         xappConn1.SendRESTSubsDelReq(t, &restSubId)
7178         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7179         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7180
7181         waitSubsCleanup(t, e2SubsId, 10)
7182         mainCtrl.VerifyAllClean(t)
7183         mainCtrl.VerifyCounterValues(t)
7184 }
7185
7186 //-----------------------------------------------------------------------------
7187 // TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle
7188 //
7189 //   stub                             stub
7190 // +-------+        +---------+    +---------+
7191 // | xapp  |        | submgr  |    | e2term  |
7192 // +-------+        +---------+    +---------+
7193 //     |                 |              |
7194 //     | RESTSubReq      |              |
7195 //     |---------------->|              |
7196 //     |                 |              |
7197 //     |     RESTSubResp |              |
7198 //     |<----------------|              |
7199 //     |                 | SubReq       |
7200 //     |                 |------------->|
7201 //     |                 |              |
7202 //     |                 |      SubResp |
7203 //     |                 |<-------------|
7204 //     |                 |              |
7205 //     |       RESTNotif |              |
7206 //     |<----------------|              |
7207 //     |                 |              |
7208 //     | RESTSubReq      |              |
7209 //     |---------------->|              |
7210 //     |                 |              |
7211 //     |     RESTSubResp |              |
7212 //     |<----------------|              |
7213 //     |                 | SubReq       |
7214 //     |                 |------------->|
7215 //     |                                |
7216 //     |           Submgr restart       |
7217 //     |                 |              |
7218 //     | RESTSubDelReq   |              |
7219 //     |---------------->|              |
7220 //     |                 |              |
7221 //     |                 | SubDelReq    |
7222 //     |                 |------------->|
7223 //     |                 |              |
7224 //     |                 |   SubDelResp |
7225 //     |                 |<-------------|
7226 //     |                 |              |
7227 //     |  RESTSubDelResp |              |
7228 //     |<----------------|              |
7229 //
7230 //-----------------------------------------------------------------------------
7231
7232 func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
7233         CaseBegin("TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle")
7234
7235         mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7236                 Counter{cRestSubReqFromXapp, 2},
7237                 Counter{cRestSubRespToXapp, 2},
7238                 Counter{cSubReqToE2, 2},
7239                 Counter{cSubRespFromE2, 1},
7240                 Counter{cRestSubNotifToXapp, 1},
7241                 Counter{cRestSubDelReqFromXapp, 1},
7242                 Counter{cSubDelReqToE2, 1},
7243                 Counter{cSubDelRespFromE2, 1},
7244                 Counter{cRestSubDelRespToXapp, 1},
7245         })
7246
7247         const e2Timeout int64 = 1
7248         const e2RetryCount int64 = 0
7249         const routingNeeded bool = false
7250
7251         // Req1
7252         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7253         params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7254         // Create subscription
7255         restSubId := xappConn1.SendRESTSubsReq(t, params)
7256         xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
7257
7258         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7259         xappConn1.ExpectRESTNotification(t, restSubId)
7260         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
7261         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7262         xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7263
7264         // Check subscription
7265         queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
7266
7267         // Policy change
7268         params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7269         params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7270         params.SetSubscriptionID(&restSubId)
7271         params.SetTimeToWait("w200ms")
7272         mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
7273         restSubId = xappConn1.SendRESTSubsReq(t, params)
7274         xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
7275
7276         crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
7277         mainCtrl.SetResetTestFlag(t, false)
7278
7279         // SubsResp is missing due to submgr restart
7280
7281         mainCtrl.SimulateRestart(t)
7282         xapp.Logger.Debug("mainCtrl.SimulateRestart done")
7283
7284         // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
7285         // That needs to be completed before successful subscription query is possible
7286         <-time.After(time.Second * 1)
7287
7288         // Check subscription
7289         queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
7290
7291         // Delete subscription
7292         xappConn1.SendRESTSubsDelReq(t, &restSubId)
7293         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7294         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7295
7296         //Wait that subs is cleaned
7297         waitSubsCleanup(t, e2SubsId, 10)
7298
7299         mainCtrl.VerifyCounterValues(t)
7300         mainCtrl.VerifyAllClean(t)
7301 }
7302
7303 ////////////////////////////////////////////////////////////////////////////////////
7304 //   Services for UT cases
7305 ////////////////////////////////////////////////////////////////////////////////////
7306 const subReqCount int = 1
7307 const host string = "localhost"
7308
7309 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
7310         if params == nil {
7311                 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
7312         }
7313         restSubId := fromXappConn.SendRESTSubsReq(t, params)
7314         xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
7315
7316         crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
7317         fromXappConn.ExpectRESTNotification(t, restSubId)
7318         toE2termConn.SendSubsResp(t, crereq1, cremsg1)
7319         e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
7320         xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7321
7322         return restSubId, e2SubsId
7323 }
7324
7325 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
7326
7327         params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
7328         if meid != "" {
7329                 params.SetMeid(meid)
7330         }
7331         xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
7332         restSubId := xappConn2.SendRESTSubsReq(t, params)
7333         xappConn2.ExpectRESTNotification(t, restSubId)
7334         xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
7335         e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
7336         xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7337
7338         return restSubId, e2SubsId
7339 }
7340
7341 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
7342
7343         params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7344         restSubId := xappConn1.SendRESTSubsReq(t, params)
7345         xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
7346
7347         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7348         xappConn1.ExpectRESTNotification(t, restSubId)
7349         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
7350         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7351         xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7352
7353         return restSubId, e2SubsId
7354 }
7355
7356 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
7357         params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7358         restSubId := xappConn1.SendRESTSubsReq(t, params)
7359
7360         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7361         fparams1 := &teststube2ap.E2StubSubsFailParams{}
7362         fparams1.Set(crereq1)
7363         e2termConn1.SendSubsFail(t, fparams1, cremsg1)
7364
7365         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
7366         xappConn1.ExpectRESTNotification(t, restSubId)
7367         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
7368         e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7369         xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
7370
7371         return restSubId, e2SubsId
7372 }
7373
7374 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
7375         fromXappConn.SendRESTSubsDelReq(t, restSubId)
7376         delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
7377         toE2termConn.SendSubsDelResp(t, delreq, delmsg)
7378 }
7379
7380 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
7381         xappConn1.SendRESTSubsDelReq(t, restSubId)
7382         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7383         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7384 }
7385
7386 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
7387         xappConn2.SendRESTSubsDelReq(t, restSubId)
7388         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7389         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7390 }
7391
7392 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
7393         resp, _ := xapp.Subscription.QuerySubscriptions()
7394         assert.Equal(t, e2SubsId, resp[0].SubscriptionID)
7395         assert.Equal(t, meid, resp[0].Meid)
7396         assert.Equal(t, endpoint, resp[0].ClientEndpoint)
7397 }
7398
7399 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
7400         //Wait that subs is cleaned
7401         mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
7402
7403         xappConn1.TestMsgChanEmpty(t)
7404         xappConn2.TestMsgChanEmpty(t)
7405         e2termConn1.TestMsgChanEmpty(t)
7406         mainCtrl.wait_registry_empty(t, timeout)
7407 }
7408
7409 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
7410
7411         var e2SubsId []uint32
7412
7413         for i := 0; i < count; i++ {
7414                 xapp.Logger.Debug("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
7415                 crereq, cremsg := toE2termConn.RecvSubsReq(t)
7416                 fromXappConn.ExpectRESTNotification(t, restSubId)
7417                 toE2termConn.SendSubsResp(t, crereq, cremsg)
7418                 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
7419                 e2SubsId = append(e2SubsId, instanceId)
7420                 xapp.Logger.Debug("TEST: %v", e2SubsId)
7421                 xapp.Logger.Debug("TEST: %d ===================================== END CRE ============================================", i+1)
7422                 <-time.After(100 * time.Millisecond)
7423         }
7424         return e2SubsId
7425 }
7426
7427 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
7428
7429         for i := 0; i < len(e2SubsIds); i++ {
7430                 xapp.Logger.Debug("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
7431                 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
7432                 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
7433                 <-time.After(1 * time.Second)
7434                 xapp.Logger.Debug("TEST: %d ===================================== END DEL ============================================", i+1)
7435                 <-time.After(100 * time.Millisecond)
7436         }
7437
7438         // Wait that subs is cleaned
7439         for i := 0; i < len(e2SubsIds); i++ {
7440                 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)
7441         }
7442
7443 }