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