pkg/control/ut_messaging_test.go

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