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         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
  24         "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststube2ap"
  25         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
  26         "github.com/stretchr/testify/assert"
  27         "testing"
  28 )
  29
  30 //-----------------------------------------------------------------------------
  31 // TestSubReqAndRouteNok
  32 //
  33 //   stub                          stub
  34 // +-------+     +---------+    +---------+
  35 // | xapp  |     | submgr  |    | rtmgr   |
  36 // +-------+     +---------+    +---------+
  37 //     |              |              |
  38 //     | SubReq       |              |
  39 //     |------------->|              |
  40 //     |              |              |
  41 //     |              | RouteCreate  |
  42 //     |              |------------->|
  43 //     |              |              |
  44 //     |              | RouteCreate  |
  45 //     |              |  status:400  |
  46 //     |              |<-------------|
  47 //     |              |              |
  48 //     |       [SUBS INT DELETE]     |
  49 //     |              |              |
  50 //
  51 //-----------------------------------------------------------------------------
  52
  53 func TestSubReqAndRouteNok(t *testing.T) {
  54         CaseBegin("TestSubReqAndRouteNok")
  55
  56         waiter := rtmgrHttp.AllocNextEvent(false)
  57         newSubsId := mainCtrl.get_subid(t)
  58         xappConn1.SendSubsReq(t, nil, nil)
  59         waiter.WaitResult(t)
  60
  61         //Wait that subs is cleaned
  62         mainCtrl.wait_subs_clean(t, newSubsId, 10)
  63
  64         xappConn1.TestMsgChanEmpty(t)
  65         xappConn2.TestMsgChanEmpty(t)
  66         e2termConn1.TestMsgChanEmpty(t)
  67         mainCtrl.wait_registry_empty(t, 10)
  68 }
  69
  70 //-----------------------------------------------------------------------------
  71 // TestSubReqAndSubDelOk
  72 //
  73 //   stub                          stub
  74 // +-------+     +---------+    +---------+
  75 // | xapp  |     | submgr  |    | e2term  |
  76 // +-------+     +---------+    +---------+
  77 //     |              |              |
  78 //     | SubReq       |              |
  79 //     |------------->|              |
  80 //     |              |              |
  81 //     |              | SubReq       |
  82 //     |              |------------->|
  83 //     |              |              |
  84 //     |              |      SubResp |
  85 //     |              |<-------------|
  86 //     |              |              |
  87 //     |      SubResp |              |
  88 //     |<-------------|              |
  89 //     |              |              |
  90 //     |              |              |
  91 //     | SubDelReq    |              |
  92 //     |------------->|              |
  93 //     |              |              |
  94 //     |              | SubDelReq    |
  95 //     |              |------------->|
  96 //     |              |              |
  97 //     |              |   SubDelResp |
  98 //     |              |<-------------|
  99 //     |              |              |
 100 //     |   SubDelResp |              |
 101 //     |<-------------|              |
 102 //
 103 //-----------------------------------------------------------------------------
 104 func TestSubReqAndSubDelOk(t *testing.T) {
 105         CaseBegin("TestSubReqAndSubDelOk")
 106
 107         cretrans := xappConn1.SendSubsReq(t, nil, nil)
 108
 109         crereq, cremsg := e2termConn1.RecvSubsReq(t)
 110         e2termConn1.SendSubsResp(t, crereq, cremsg)
 111         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
 112
 113         resp, _ := xapp.Subscription.QuerySubscriptions()
 114         assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
 115         assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
 116         assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560"})
 117
 118         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
 119         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
 120
 121         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
 122         xappConn1.RecvSubsDelResp(t, deltrans)
 123
 124         //Wait that subs is cleaned
 125         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 126
 127         xappConn1.TestMsgChanEmpty(t)
 128         xappConn2.TestMsgChanEmpty(t)
 129         e2termConn1.TestMsgChanEmpty(t)
 130         mainCtrl.wait_registry_empty(t, 10)
 131 }
 132
 133 //-----------------------------------------------------------------------------
 134 // TestSubReqRetransmission
 135 //
 136 //   stub                          stub
 137 // +-------+     +---------+    +---------+
 138 // | xapp  |     | submgr  |    | e2term  |
 139 // +-------+     +---------+    +---------+
 140 //     |              |              |
 141 //     |  SubReq      |              |
 142 //     |------------->|              |
 143 //     |              |              |
 144 //     |              | SubReq       |
 145 //     |              |------------->|
 146 //     |              |              |
 147 //     |  SubReq      |              |
 148 //     | (retrans)    |              |
 149 //     |------------->|              |
 150 //     |              |              |
 151 //     |              |      SubResp |
 152 //     |              |<-------------|
 153 //     |              |              |
 154 //     |      SubResp |              |
 155 //     |<-------------|              |
 156 //     |              |              |
 157 //     |         [SUBS DELETE]       |
 158 //     |              |              |
 159 //
 160 //-----------------------------------------------------------------------------
 161 func TestSubReqRetransmission(t *testing.T) {
 162         CaseBegin("TestSubReqRetransmission")
 163
 164         //Subs Create
 165         cretrans := xappConn1.SendSubsReq(t, nil, nil)
 166         crereq, cremsg := e2termConn1.RecvSubsReq(t)
 167
 168         seqBef := mainCtrl.get_msgcounter(t)
 169         xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq
 170         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 171
 172         e2termConn1.SendSubsResp(t, crereq, cremsg)
 173         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
 174
 175         //Subs Delete
 176         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
 177         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
 178         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
 179         xappConn1.RecvSubsDelResp(t, deltrans)
 180
 181         //Wait that subs is cleaned
 182         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 183
 184         xappConn1.TestMsgChanEmpty(t)
 185         xappConn2.TestMsgChanEmpty(t)
 186         e2termConn1.TestMsgChanEmpty(t)
 187         mainCtrl.wait_registry_empty(t, 10)
 188 }
 189
 190 //-----------------------------------------------------------------------------
 191 // TestSubDelReqRetransmission
 192 //
 193 //   stub                          stub
 194 // +-------+     +---------+    +---------+
 195 // | xapp  |     | submgr  |    | e2term  |
 196 // +-------+     +---------+    +---------+
 197 //     |              |              |
 198 //     |         [SUBS CREATE]       |
 199 //     |              |              |
 200 //     |              |              |
 201 //     | SubDelReq    |              |
 202 //     |------------->|              |
 203 //     |              |              |
 204 //     |              | SubDelReq    |
 205 //     |              |------------->|
 206 //     |              |              |
 207 //     | SubDelReq    |              |
 208 //     | (same sub)   |              |
 209 //     | (same xid)   |              |
 210 //     |------------->|              |
 211 //     |              |              |
 212 //     |              |   SubDelResp |
 213 //     |              |<-------------|
 214 //     |              |              |
 215 //     |   SubDelResp |              |
 216 //     |<-------------|              |
 217 //
 218 //-----------------------------------------------------------------------------
 219 func TestSubDelReqRetransmission(t *testing.T) {
 220         CaseBegin("TestSubDelReqRetransmission")
 221
 222         //Subs Create
 223         cretrans := xappConn1.SendSubsReq(t, nil, nil)
 224         crereq, cremsg := e2termConn1.RecvSubsReq(t)
 225         e2termConn1.SendSubsResp(t, crereq, cremsg)
 226         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
 227
 228         //Subs Delete
 229         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
 230         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
 231
 232         seqBef := mainCtrl.get_msgcounter(t)
 233         xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq
 234         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 235
 236         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
 237         xappConn1.RecvSubsDelResp(t, deltrans)
 238
 239         //Wait that subs is cleaned
 240         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 241
 242         xappConn1.TestMsgChanEmpty(t)
 243         xappConn2.TestMsgChanEmpty(t)
 244         e2termConn1.TestMsgChanEmpty(t)
 245         mainCtrl.wait_registry_empty(t, 10)
 246 }
 247
 248 //-----------------------------------------------------------------------------
 249 // TestSubDelReqCollision
 250 //
 251 //   stub                          stub
 252 // +-------+     +---------+    +---------+
 253 // | xapp  |     | submgr  |    | e2term  |
 254 // +-------+     +---------+    +---------+
 255 //     |              |              |
 256 //     |         [SUBS CREATE]       |
 257 //     |              |              |
 258 //     |              |              |
 259 //     | SubDelReq 1  |              |
 260 //     |------------->|              |
 261 //     |              |              |
 262 //     |              | SubDelReq 1  |
 263 //     |              |------------->|
 264 //     |              |              |
 265 //     | SubDelReq 2  |              |
 266 //     | (same sub)   |              |
 267 //     | (diff xid)   |              |
 268 //     |------------->|              |
 269 //     |              |              |
 270 //     |              | SubDelResp 1 |
 271 //     |              |<-------------|
 272 //     |              |              |
 273 //     | SubDelResp 1 |              |
 274 //     |<-------------|              |
 275 //     |              |              |
 276 //     | SubDelResp 2 |              |
 277 //     |<-------------|              |
 278 //
 279 //-----------------------------------------------------------------------------
 280
 281 func TestSubDelReqCollision(t *testing.T) {
 282         CaseBegin("TestSubDelReqCollision")
 283
 284         //Subs Create
 285         cretrans := xappConn1.SendSubsReq(t, nil, nil)
 286         crereq, cremsg := e2termConn1.RecvSubsReq(t)
 287         e2termConn1.SendSubsResp(t, crereq, cremsg)
 288         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
 289
 290         //Subs Delete
 291         xappConn1.SendSubsDelReq(t, nil, e2SubsId)
 292         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
 293
 294         // Subs Delete colliding
 295         seqBef := mainCtrl.get_msgcounter(t)
 296         deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
 297         xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq
 298         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 299
 300         // Del resp for first and second
 301         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
 302
 303         // don't care in which order responses are received
 304         xappConn1.RecvSubsDelResp(t, nil)
 305         xappConn1.RecvSubsDelResp(t, nil)
 306
 307         //Wait that subs is cleaned
 308         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 309
 310         xappConn1.TestMsgChanEmpty(t)
 311         xappConn2.TestMsgChanEmpty(t)
 312         e2termConn1.TestMsgChanEmpty(t)
 313         mainCtrl.wait_registry_empty(t, 10)
 314 }
 315
 316 //-----------------------------------------------------------------------------
 317 // TestSubReqAndSubDelOkTwoParallel
 318 //
 319 //   stub       stub                          stub
 320 // +-------+  +-------+     +---------+    +---------+
 321 // | xapp  |  | xapp  |     | submgr  |    | e2term  |
 322 // +-------+  +-------+     +---------+    +---------+
 323 //     |          |              |              |
 324 //     |          |              |              |
 325 //     |          |              |              |
 326 //     |          | SubReq1      |              |
 327 //     |          |------------->|              |
 328 //     |          |              |              |
 329 //     |          |              | SubReq1      |
 330 //     |          |              |------------->|
 331 //     |          |              |              |
 332 //     |       SubReq2           |              |
 333 //     |------------------------>|              |
 334 //     |          |              |              |
 335 //     |          |              | SubReq2      |
 336 //     |          |              |------------->|
 337 //     |          |              |              |
 338 //     |          |              |    SubResp1  |
 339 //     |          |              |<-------------|
 340 //     |          |    SubResp1  |              |
 341 //     |          |<-------------|              |
 342 //     |          |              |              |
 343 //     |          |              |    SubResp2  |
 344 //     |          |              |<-------------|
 345 //     |       SubResp2          |              |
 346 //     |<------------------------|              |
 347 //     |          |              |              |
 348 //     |          |        [SUBS 1 DELETE]      |
 349 //     |          |              |              |
 350 //     |          |        [SUBS 2 DELETE]      |
 351 //     |          |              |              |
 352 //
 353 //-----------------------------------------------------------------------------
 354 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
 355         CaseBegin("TestSubReqAndSubDelOkTwoParallel")
 356
 357         //Req1
 358         rparams1 := &teststube2ap.E2StubSubsReqParams{}
 359         rparams1.Init()
 360         rparams1.Req.EventTriggerDefinition.ProcedureCode = 5
 361         cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
 362         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
 363
 364         //Req2
 365         rparams2 := &teststube2ap.E2StubSubsReqParams{}
 366         rparams2.Init()
 367         rparams2.Req.EventTriggerDefinition.ProcedureCode = 28
 368         cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
 369         crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
 370
 371         //Resp1
 372         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
 373         e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
 374
 375         //Resp2
 376         e2termConn1.SendSubsResp(t, crereq2, cremsg2)
 377         e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
 378
 379         //Del1
 380         deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
 381         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
 382         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
 383         xappConn1.RecvSubsDelResp(t, deltrans1)
 384         //Wait that subs is cleaned
 385         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
 386
 387         //Del2
 388         deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
 389         delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
 390         e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
 391         xappConn2.RecvSubsDelResp(t, deltrans2)
 392         //Wait that subs is cleaned
 393         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
 394
 395         xappConn1.TestMsgChanEmpty(t)
 396         xappConn2.TestMsgChanEmpty(t)
 397         e2termConn1.TestMsgChanEmpty(t)
 398         mainCtrl.wait_registry_empty(t, 10)
 399 }
 400
 401 //-----------------------------------------------------------------------------
 402 // TestSameSubsDiffRan
 403 // Same subscription to different RANs
 404 //
 405 //   stub                          stub
 406 // +-------+     +---------+    +---------+
 407 // | xapp  |     | submgr  |    | e2term  |
 408 // +-------+     +---------+    +---------+
 409 //     |              |              |
 410 //     |              |              |
 411 //     |              |              |
 412 //     | SubReq(r1)   |              |
 413 //     |------------->|              |
 414 //     |              |              |
 415 //     |              | SubReq(r1)   |
 416 //     |              |------------->|
 417 //     |              |              |
 418 //     |              | SubResp(r1)  |
 419 //     |              |<-------------|
 420 //     |              |              |
 421 //     | SubResp(r1)  |              |
 422 //     |<-------------|              |
 423 //     |              |              |
 424 //     | SubReq(r2)   |              |
 425 //     |------------->|              |
 426 //     |              |              |
 427 //     |              | SubReq(r2)   |
 428 //     |              |------------->|
 429 //     |              |              |
 430 //     |              | SubResp(r2)  |
 431 //     |              |<-------------|
 432 //     |              |              |
 433 //     | SubResp(r2)  |              |
 434 //     |<-------------|              |
 435 //     |              |              |
 436 //     |       [SUBS r1 DELETE]      |
 437 //     |              |              |
 438 //     |       [SUBS r2 DELETE]      |
 439 //     |              |              |
 440 //
 441 //-----------------------------------------------------------------------------
 442 func TestSameSubsDiffRan(t *testing.T) {
 443         CaseBegin("TestSameSubsDiffRan")
 444
 445         //Req1
 446         cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
 447         xappConn1.SendSubsReq(t, nil, cretrans1)
 448         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
 449         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
 450         e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
 451
 452         //Req2
 453         cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
 454         xappConn1.SendSubsReq(t, nil, cretrans2)
 455         crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
 456         e2termConn1.SendSubsResp(t, crereq2, cremsg2)
 457         e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
 458
 459         //Del1
 460         deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
 461         xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
 462         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
 463         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
 464         xappConn1.RecvSubsDelResp(t, deltrans1)
 465         //Wait that subs is cleaned
 466         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
 467
 468         //Del2
 469         deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
 470         xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
 471         delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
 472         e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
 473         xappConn1.RecvSubsDelResp(t, deltrans2)
 474         //Wait that subs is cleaned
 475         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
 476
 477         xappConn1.TestMsgChanEmpty(t)
 478         xappConn2.TestMsgChanEmpty(t)
 479         e2termConn1.TestMsgChanEmpty(t)
 480         mainCtrl.wait_registry_empty(t, 10)
 481 }
 482
 483 //-----------------------------------------------------------------------------
 484 // TestSubReqRetryInSubmgr
 485 //
 486 //   stub                          stub
 487 // +-------+     +---------+    +---------+
 488 // | xapp  |     | submgr  |    | e2term  |
 489 // +-------+     +---------+    +---------+
 490 //     |              |              |
 491 //     |  SubReq      |              |
 492 //     |------------->|              |
 493 //     |              |              |
 494 //     |              | SubReq       |
 495 //     |              |------------->|
 496 //     |              |              |
 497 //     |              |              |
 498 //     |              | SubReq       |
 499 //     |              |------------->|
 500 //     |              |              |
 501 //     |              |      SubResp |
 502 //     |              |<-------------|
 503 //     |              |              |
 504 //     |      SubResp |              |
 505 //     |<-------------|              |
 506 //     |              |              |
 507 //     |         [SUBS DELETE]       |
 508 //     |              |              |
 509 //
 510 //-----------------------------------------------------------------------------
 511
 512 func TestSubReqRetryInSubmgr(t *testing.T) {
 513
 514         CaseBegin("TestSubReqRetryInSubmgr start")
 515
 516         // Xapp: Send SubsReq
 517         cretrans := xappConn1.SendSubsReq(t, nil, nil)
 518
 519         // E2t: Receive 1st SubsReq
 520         e2termConn1.RecvSubsReq(t)
 521
 522         // E2t: Receive 2nd SubsReq and send SubsResp
 523         crereq, cremsg := e2termConn1.RecvSubsReq(t)
 524         e2termConn1.SendSubsResp(t, crereq, cremsg)
 525
 526         // Xapp: Receive SubsResp
 527         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
 528
 529         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
 530         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
 531         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
 532         xappConn1.RecvSubsDelResp(t, deltrans)
 533
 534         // Wait that subs is cleaned
 535         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 536
 537         xappConn1.TestMsgChanEmpty(t)
 538         xappConn2.TestMsgChanEmpty(t)
 539         e2termConn1.TestMsgChanEmpty(t)
 540         mainCtrl.wait_registry_empty(t, 10)
 541 }
 542
 543 //-----------------------------------------------------------------------------
 544 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
 545 //
 546 //   stub                          stub
 547 // +-------+     +---------+    +---------+
 548 // | xapp  |     | submgr  |    | e2term  |
 549 // +-------+     +---------+    +---------+
 550 //     |              |              |
 551 //     |  SubReq      |              |
 552 //     |------------->|              |
 553 //     |              |              |
 554 //     |              | SubReq       |
 555 //     |              |------------->|
 556 //     |              |              |
 557 //     |              |              |
 558 //     |              | SubReq       |
 559 //     |              |------------->|
 560 //     |              |              |
 561 //     |              | SubDelReq    |
 562 //     |              |------------->|
 563 //     |              |              |
 564 //     |              |              |
 565 //     |              | SubDelReq    |
 566 //     |              |------------->|
 567 //     |              |              |
 568 //     |              |              |
 569 //     |              |   SubDelResp |
 570 //     |              |<-------------|
 571 //     |              |              |
 572 //
 573 //-----------------------------------------------------------------------------
 574
 575 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
 576
 577         CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
 578
 579         // Xapp: Send SubsReq
 580         xappConn1.SendSubsReq(t, nil, nil)
 581
 582         // E2t: Receive 1st SubsReq
 583         e2termConn1.RecvSubsReq(t)
 584
 585         // E2t: Receive 2nd SubsReq
 586         e2termConn1.RecvSubsReq(t)
 587
 588         // E2t: Send receive SubsDelReq and send SubsResp
 589         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
 590         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
 591
 592         // Wait that subs is cleaned
 593         mainCtrl.wait_subs_clean(t, delreq.RequestId.Seq, 10)
 594
 595         xappConn1.TestMsgChanEmpty(t)
 596         xappConn2.TestMsgChanEmpty(t)
 597         e2termConn1.TestMsgChanEmpty(t)
 598         mainCtrl.wait_registry_empty(t, 10)
 599 }
 600
 601 //-----------------------------------------------------------------------------
 602 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
 603 //
 604 //   stub                          stub
 605 // +-------+     +---------+    +---------+
 606 // | xapp  |     | submgr  |    | e2term  |
 607 // +-------+     +---------+    +---------+
 608 //     |              |              |
 609 //     |  SubReq      |              |
 610 //     |------------->|              |
 611 //     |              |              |
 612 //     |              | SubReq       |
 613 //     |              |------------->|
 614 //     |              |              |
 615 //     |              |              |
 616 //     |              | SubReq       |
 617 //     |              |------------->|
 618 //     |              |              |
 619 //     |              | SubDelReq    |
 620 //     |              |------------->|
 621 //     |              |              |
 622 //     |              |              |
 623 //     |              | SubDelReq    |
 624 //     |              |------------->|
 625 //     |              |              |
 626 //     |              |              |
 627 //
 628 //-----------------------------------------------------------------------------
 629
 630 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
 631
 632         CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
 633
 634         // Xapp: Send SubsReq
 635         xappConn1.SendSubsReq(t, nil, nil)
 636
 637         // E2t: Receive 1st SubsReq
 638         e2termConn1.RecvSubsReq(t)
 639
 640         // E2t: Receive 2nd SubsReq
 641         e2termConn1.RecvSubsReq(t)
 642
 643         // E2t: Receive 1st SubsDelReq
 644         e2termConn1.RecvSubsDelReq(t)
 645
 646         // E2t: Receive 2nd SubsDelReq
 647         delreq, _ := e2termConn1.RecvSubsDelReq(t)
 648
 649         // Wait that subs is cleaned
 650         mainCtrl.wait_subs_clean(t, delreq.RequestId.Seq, 15)
 651
 652         xappConn1.TestMsgChanEmpty(t)
 653         xappConn2.TestMsgChanEmpty(t)
 654         e2termConn1.TestMsgChanEmpty(t)
 655         mainCtrl.wait_registry_empty(t, 10)
 656 }
 657
 658 //-----------------------------------------------------------------------------
 659 // TestSubReqSubFailRespInSubmgr
 660 //
 661 //   stub                          stub
 662 // +-------+     +---------+    +---------+
 663 // | xapp  |     | submgr  |    | e2term  |
 664 // +-------+     +---------+    +---------+
 665 //     |              |              |
 666 //     |  SubReq      |              |
 667 //     |------------->|              |
 668 //     |              |              |
 669 //     |              | SubReq       |
 670 //     |              |------------->|
 671 //     |              |              |
 672 //     |              |      SubFail |
 673 //     |              |<-------------|
 674 //     |              |              |
 675 //     |      SubFail |              |
 676 //     |<-------------|              |
 677 //     |              |              |
 678 //
 679 //-----------------------------------------------------------------------------
 680
 681 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
 682
 683         CaseBegin("TestSubReqSubFailRespInSubmgr start")
 684
 685         // Xapp: Send SubsReq
 686         cretrans := xappConn1.SendSubsReq(t, nil, nil)
 687
 688         // E2t: Receive SubsReq and send SubsFail
 689         crereq, cremsg := e2termConn1.RecvSubsReq(t)
 690         fparams := &teststube2ap.E2StubSubsFailParams{}
 691         fparams.Set(crereq)
 692         e2termConn1.SendSubsFail(t, fparams, cremsg)
 693
 694         // Xapp: Receive SubsFail
 695         e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
 696
 697         // Wait that subs is cleaned
 698         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 699
 700         xappConn1.TestMsgChanEmpty(t)
 701         xappConn2.TestMsgChanEmpty(t)
 702         e2termConn1.TestMsgChanEmpty(t)
 703         mainCtrl.wait_registry_empty(t, 10)
 704 }
 705
 706 //-----------------------------------------------------------------------------
 707 // TestSubDelReqRetryInSubmgr
 708 //
 709 //   stub                          stub
 710 // +-------+     +---------+    +---------+
 711 // | xapp  |     | submgr  |    | e2term  |
 712 // +-------+     +---------+    +---------+
 713 //     |              |              |
 714 //     |         [SUBS CREATE]       |
 715 //     |              |              |
 716 //     |              |              |
 717 //     | SubDelReq    |              |
 718 //     |------------->|              |
 719 //     |              |              |
 720 //     |              | SubDelReq    |
 721 //     |              |------------->|
 722 //     |              |              |
 723 //     |              | SubDelReq    |
 724 //     |              |------------->|
 725 //     |              |              |
 726 //     |              |   SubDelResp |
 727 //     |              |<-------------|
 728 //     |              |              |
 729 //     |   SubDelResp |              |
 730 //     |<-------------|              |
 731 //
 732 //-----------------------------------------------------------------------------
 733
 734 func TestSubDelReqRetryInSubmgr(t *testing.T) {
 735
 736         CaseBegin("TestSubDelReqRetryInSubmgr start")
 737
 738         // Subs Create
 739         cretrans := xappConn1.SendSubsReq(t, nil, nil)
 740         crereq, cremsg := e2termConn1.RecvSubsReq(t)
 741         e2termConn1.SendSubsResp(t, crereq, cremsg)
 742         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
 743
 744         // Subs Delete
 745         // Xapp: Send SubsDelReq
 746         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
 747
 748         // E2t: Receive 1st SubsDelReq
 749         e2termConn1.RecvSubsDelReq(t)
 750
 751         // E2t: Receive 2nd SubsDelReq and send SubsDelResp
 752         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
 753         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
 754
 755         // Xapp: Receive SubsDelResp
 756         xappConn1.RecvSubsDelResp(t, deltrans)
 757
 758         // Wait that subs is cleaned
 759         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 760
 761         xappConn1.TestMsgChanEmpty(t)
 762         xappConn2.TestMsgChanEmpty(t)
 763         e2termConn1.TestMsgChanEmpty(t)
 764         mainCtrl.wait_registry_empty(t, 10)
 765 }
 766
 767 //-----------------------------------------------------------------------------
 768 // TestSubDelReqTwoRetriesNoRespInSubmgr
 769 //
 770 //   stub                          stub
 771 // +-------+     +---------+    +---------+
 772 // | xapp  |     | submgr  |    | e2term  |
 773 // +-------+     +---------+    +---------+
 774 //     |              |              |
 775 //     |         [SUBS CREATE]       |
 776 //     |              |              |
 777 //     |              |              |
 778 //     | SubDelReq    |              |
 779 //     |------------->|              |
 780 //     |              |              |
 781 //     |              | SubDelReq    |
 782 //     |              |------------->|
 783 //     |              |              |
 784 //     |              | SubDelReq    |
 785 //     |              |------------->|
 786 //     |              |              |
 787 //     |              |              |
 788 //     |   SubDelResp |              |
 789 //     |<-------------|              |
 790 //
 791 //-----------------------------------------------------------------------------
 792
 793 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
 794
 795         CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
 796
 797         // Subs Create
 798         cretrans := xappConn1.SendSubsReq(t, nil, nil)
 799         crereq, cremsg := e2termConn1.RecvSubsReq(t)
 800         e2termConn1.SendSubsResp(t, crereq, cremsg)
 801         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
 802
 803         // Subs Delete
 804         // Xapp: Send SubsDelReq
 805         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
 806
 807         // E2t: Receive 1st SubsDelReq
 808         e2termConn1.RecvSubsDelReq(t)
 809
 810         // E2t: Receive 2nd SubsDelReq
 811         e2termConn1.RecvSubsDelReq(t)
 812
 813         // Xapp: Receive SubsDelResp
 814         xappConn1.RecvSubsDelResp(t, deltrans)
 815
 816         // Wait that subs is cleaned
 817         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 818
 819         xappConn1.TestMsgChanEmpty(t)
 820         xappConn2.TestMsgChanEmpty(t)
 821         e2termConn1.TestMsgChanEmpty(t)
 822         mainCtrl.wait_registry_empty(t, 10)
 823 }
 824
 825 //-----------------------------------------------------------------------------
 826 // TestSubDelReqSubDelFailRespInSubmgr
 827 //
 828 //   stub                          stub
 829 // +-------+     +---------+    +---------+
 830 // | xapp  |     | submgr  |    | e2term  |
 831 // +-------+     +---------+    +---------+
 832 //     |              |              |
 833 //     |         [SUBS CREATE]       |
 834 //     |              |              |
 835 //     |              |              |
 836 //     |  SubDelReq   |              |
 837 //     |------------->|              |
 838 //     |              |              |
 839 //     |              | SubDelReq    |
 840 //     |              |------------->|
 841 //     |              |              |
 842 //     |              |   SubDelFail |
 843 //     |              |<-------------|
 844 //     |              |              |
 845 //     |   SubDelResp |              |
 846 //     |<-------------|              |
 847 //     |              |              |
 848 //
 849 //-----------------------------------------------------------------------------
 850
 851 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
 852
 853         CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
 854
 855         // Subs Create
 856         cretrans := xappConn1.SendSubsReq(t, nil, nil)
 857         crereq, cremsg := e2termConn1.RecvSubsReq(t)
 858         e2termConn1.SendSubsResp(t, crereq, cremsg)
 859         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
 860
 861         // Xapp: Send SubsDelReq
 862         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
 863
 864         // E2t: Send receive SubsDelReq and send SubsDelFail
 865         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
 866         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
 867
 868         // Xapp: Receive SubsDelResp
 869         xappConn1.RecvSubsDelResp(t, deltrans)
 870
 871         // Wait that subs is cleaned
 872         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 873
 874         xappConn1.TestMsgChanEmpty(t)
 875         xappConn2.TestMsgChanEmpty(t)
 876         e2termConn1.TestMsgChanEmpty(t)
 877         mainCtrl.wait_registry_empty(t, 10)
 878 }
 879
 880 //-----------------------------------------------------------------------------
 881 // TestSubReqAndSubDelOkSameAction
 882 //
 883 //   stub                          stub
 884 // +-------+     +-------+     +---------+    +---------+
 885 // | xapp2 |     | xapp1 |     | submgr  |    | e2term  |
 886 // +-------+     +-------+     +---------+    +---------+
 887 //     |             |              |              |
 888 //     |             |              |              |
 889 //     |             |              |              |
 890 //     |             | SubReq1      |              |
 891 //     |             |------------->|              |
 892 //     |             |              |              |
 893 //     |             |              | SubReq1      |
 894 //     |             |              |------------->|
 895 //     |             |              |    SubResp1  |
 896 //     |             |              |<-------------|
 897 //     |             |    SubResp1  |              |
 898 //     |             |<-------------|              |
 899 //     |             |              |              |
 900 //     |          SubReq2           |              |
 901 //     |--------------------------->|              |
 902 //     |             |              |              |
 903 //     |          SubResp2          |              |
 904 //     |<---------------------------|              |
 905 //     |             |              |              |
 906 //     |             | SubDelReq 1  |              |
 907 //     |             |------------->|              |
 908 //     |             |              |              |
 909 //     |             | SubDelResp 1 |              |
 910 //     |             |<-------------|              |
 911 //     |             |              |              |
 912 //     |         SubDelReq 2        |              |
 913 //     |--------------------------->|              |
 914 //     |             |              |              |
 915 //     |             |              | SubDelReq 2  |
 916 //     |             |              |------------->|
 917 //     |             |              |              |
 918 //     |             |              | SubDelReq 2  |
 919 //     |             |              |------------->|
 920 //     |             |              |              |
 921 //     |         SubDelResp 2       |              |
 922 //     |<---------------------------|              |
 923 //
 924 //-----------------------------------------------------------------------------
 925 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
 926         CaseBegin("TestSubReqAndSubDelOkSameAction")
 927
 928         //Req1
 929         rparams1 := &teststube2ap.E2StubSubsReqParams{}
 930         rparams1.Init()
 931         cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
 932         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
 933         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
 934         e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
 935
 936         //Req2
 937         rparams2 := &teststube2ap.E2StubSubsReqParams{}
 938         rparams2.Init()
 939         cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
 940         //crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
 941         //e2termConn1.SendSubsResp(t, crereq2, cremsg2)
 942         e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
 943
 944         resp, _ := xapp.Subscription.QuerySubscriptions()
 945         assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
 946         assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
 947         assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560", "localhost:13660"})
 948
 949         //Del1
 950         deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
 951         //e2termConn1.RecvSubsDelReq(t)
 952         //e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
 953         xappConn1.RecvSubsDelResp(t, deltrans1)
 954         //Wait that subs is cleaned
 955         //mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
 956
 957         //Del2
 958         deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
 959         delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
 960         e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
 961         xappConn2.RecvSubsDelResp(t, deltrans2)
 962         //Wait that subs is cleaned
 963         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
 964
 965         xappConn1.TestMsgChanEmpty(t)
 966         xappConn2.TestMsgChanEmpty(t)
 967         e2termConn1.TestMsgChanEmpty(t)
 968         mainCtrl.wait_registry_empty(t, 10)
 969 }
 970
 971 //-----------------------------------------------------------------------------
 972 // TestSubReqAndSubDelOkSameActionParallel
 973 //
 974 //   stub          stub                          stub
 975 // +-------+     +-------+     +---------+    +---------+
 976 // | xapp2 |     | xapp1 |     | submgr  |    | e2term  |
 977 // +-------+     +-------+     +---------+    +---------+
 978 //     |             |              |              |
 979 //     |             |              |              |
 980 //     |             |              |              |
 981 //     |             | SubReq1      |              |
 982 //     |             |------------->|              |
 983 //     |             |              |              |
 984 //     |             |              | SubReq1      |
 985 //     |             |              |------------->|
 986 //     |          SubReq2           |              |
 987 //     |--------------------------->|              |
 988 //     |             |              |    SubResp1  |
 989 //     |             |              |<-------------|
 990 //     |             |    SubResp1  |              |
 991 //     |             |<-------------|              |
 992 //     |             |              |              |
 993 //     |          SubResp2          |              |
 994 //     |<---------------------------|              |
 995 //     |             |              |              |
 996 //     |             | SubDelReq 1  |              |
 997 //     |             |------------->|              |
 998 //     |             |              |              |
 999 //     |             | SubDelResp 1 |              |
1000 //     |             |<-------------|              |
1001 //     |             |              |              |
1002 //     |         SubDelReq 2        |              |
1003 //     |--------------------------->|              |
1004 //     |             |              |              |
1005 //     |             |              | SubDelReq 2  |
1006 //     |             |              |------------->|
1007 //     |             |              |              |
1008 //     |             |              | SubDelReq 2  |
1009 //     |             |              |------------->|
1010 //     |             |              |              |
1011 //     |         SubDelResp 2       |              |
1012 //     |<---------------------------|              |
1013 //
1014 //-----------------------------------------------------------------------------
1015 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1016         CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1017
1018         //Req1
1019         rparams1 := &teststube2ap.E2StubSubsReqParams{}
1020         rparams1.Init()
1021         cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1022         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1023
1024         //Req2
1025         rparams2 := &teststube2ap.E2StubSubsReqParams{}
1026         rparams2.Init()
1027         cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1028
1029         //Resp1
1030         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1031         e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1032
1033         //Resp2
1034         e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1035
1036         //Del1
1037         deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1038         xappConn1.RecvSubsDelResp(t, deltrans1)
1039
1040         //Del2
1041         deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1042         delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1043         e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1044         xappConn2.RecvSubsDelResp(t, deltrans2)
1045
1046         //Wait that subs is cleaned
1047         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1048
1049         xappConn1.TestMsgChanEmpty(t)
1050         xappConn2.TestMsgChanEmpty(t)
1051         e2termConn1.TestMsgChanEmpty(t)
1052         mainCtrl.wait_registry_empty(t, 10)
1053 }
1054
1055 //-----------------------------------------------------------------------------
1056 // TestSubReqAndSubDelNokSameActionParallel
1057 //
1058 //   stub          stub                          stub
1059 // +-------+     +-------+     +---------+    +---------+
1060 // | xapp2 |     | xapp1 |     | submgr  |    | e2term  |
1061 // +-------+     +-------+     +---------+    +---------+
1062 //     |             |              |              |
1063 //     |             |              |              |
1064 //     |             |              |              |
1065 //     |             | SubReq1      |              |
1066 //     |             |------------->|              |
1067 //     |             |              |              |
1068 //     |             |              | SubReq1      |
1069 //     |             |              |------------->|
1070 //     |          SubReq2           |              |
1071 //     |--------------------------->|              |
1072 //     |             |              |    SubFail1  |
1073 //     |             |              |<-------------|
1074 //     |             |    SubFail1  |              |
1075 //     |             |<-------------|              |
1076 //     |             |              |              |
1077 //     |          SubFail2          |              |
1078 //     |<---------------------------|              |
1079 //
1080 //-----------------------------------------------------------------------------
1081 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1082         CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1083
1084         //Req1
1085         rparams1 := &teststube2ap.E2StubSubsReqParams{}
1086         rparams1.Init()
1087         cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1088         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1089
1090         //Req2
1091         rparams2 := &teststube2ap.E2StubSubsReqParams{}
1092         rparams2.Init()
1093         seqBef2 := mainCtrl.get_msgcounter(t)
1094         cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1095         mainCtrl.wait_msgcounter_change(t, seqBef2, 10)
1096
1097         //E2T Fail
1098         fparams := &teststube2ap.E2StubSubsFailParams{}
1099         fparams.Set(crereq1)
1100         e2termConn1.SendSubsFail(t, fparams, cremsg1)
1101
1102         //Fail1
1103         e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1104         //Fail2
1105         xappConn2.RecvSubsFail(t, cretrans2)
1106
1107         //Wait that subs is cleaned
1108         mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1109
1110         xappConn1.TestMsgChanEmpty(t)
1111         xappConn2.TestMsgChanEmpty(t)
1112         e2termConn1.TestMsgChanEmpty(t)
1113         mainCtrl.wait_registry_empty(t, 10)
1114 }
1115
1116 //-----------------------------------------------------------------------------
1117 // TestSubReqAndSubDelNoAnswerSameActionParallel
1118 //
1119 //   stub          stub                          stub
1120 // +-------+     +-------+     +---------+    +---------+
1121 // | xapp2 |     | xapp1 |     | submgr  |    | e2term  |
1122 // +-------+     +-------+     +---------+    +---------+
1123 //     |             |              |              |
1124 //     |             |              |              |
1125 //     |             |              |              |
1126 //     |             | SubReq1      |              |
1127 //     |             |------------->|              |
1128 //     |             |              |              |
1129 //     |             |              | SubReq1      |
1130 //     |             |              |------------->|
1131 //     |             | SubReq2      |              |
1132 //     |--------------------------->|              |
1133 //     |             |              |              |
1134 //     |             |              | SubReq1      |
1135 //     |             |              |------------->|
1136 //     |             |              |              |
1137 //     |             |              |              |
1138 //     |             |              | SubDelReq    |
1139 //     |             |              |------------->|
1140 //     |             |              |              |
1141 //     |             |              |   SubDelResp |
1142 //     |             |              |<-------------|
1143 //
1144 //-----------------------------------------------------------------------------
1145 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1146         CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1147
1148         //Req1
1149         rparams1 := &teststube2ap.E2StubSubsReqParams{}
1150         rparams1.Init()
1151         xappConn1.SendSubsReq(t, rparams1, nil)
1152
1153         e2termConn1.RecvSubsReq(t)
1154
1155         //Req2
1156         rparams2 := &teststube2ap.E2StubSubsReqParams{}
1157         rparams2.Init()
1158         seqBef2 := mainCtrl.get_msgcounter(t)
1159         xappConn2.SendSubsReq(t, rparams2, nil)
1160         mainCtrl.wait_msgcounter_change(t, seqBef2, 10)
1161
1162         //Req1 (retransmitted)
1163         e2termConn1.RecvSubsReq(t)
1164
1165         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1166         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1167
1168         //Wait that subs is cleaned
1169         mainCtrl.wait_subs_clean(t, delreq1.RequestId.Seq, 10)
1170
1171         xappConn1.TestMsgChanEmpty(t)
1172         xappConn2.TestMsgChanEmpty(t)
1173         e2termConn1.TestMsgChanEmpty(t)
1174         mainCtrl.wait_registry_empty(t, 15)
1175 }
1176
1177 //-----------------------------  Policy cases ---------------------------------
1178 //-----------------------------------------------------------------------------
1179 // TestSubReqPolicyAndSubDelOk
1180 //
1181 //   stub                          stub
1182 // +-------+     +---------+    +---------+
1183 // | xapp  |     | submgr  |    | e2term  |
1184 // +-------+     +---------+    +---------+
1185 //     |              |              |
1186 //     | SubReq       |              |
1187 //     |------------->|              |
1188 //     |              |              |
1189 //     |              | SubReq       |
1190 //     |              |------------->|
1191 //     |              |              |
1192 //     |              |      SubResp |
1193 //     |              |<-------------|
1194 //     |              |              |
1195 //     |      SubResp |              |
1196 //     |<-------------|              |
1197 //     |              |              |
1198 //     |              |              |
1199 //     | SubDelReq    |              |
1200 //     |------------->|              |
1201 //     |              |              |
1202 //     |              | SubDelReq    |
1203 //     |              |------------->|
1204 //     |              |              |
1205 //     |              |   SubDelResp |
1206 //     |              |<-------------|
1207 //     |              |              |
1208 //     |   SubDelResp |              |
1209 //     |<-------------|              |
1210 //
1211 //-----------------------------------------------------------------------------
1212 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
1213         CaseBegin("TestSubReqAndSubDelOk")
1214
1215         rparams1 := &teststube2ap.E2StubSubsReqParams{}
1216         rparams1.Init()
1217         rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1218         cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1219
1220         crereq, cremsg := e2termConn1.RecvSubsReq(t)
1221         e2termConn1.SendSubsResp(t, crereq, cremsg)
1222         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1223         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1224         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1225
1226         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1227         xappConn1.RecvSubsDelResp(t, deltrans)
1228
1229         //Wait that subs is cleaned
1230         mainCtrl.wait_subs_clean(t, e2SubsId, 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 // TestSubReqPolicyChangeAndSubDelOk
1240 //
1241 //   stub                          stub
1242 // +-------+     +---------+    +---------+
1243 // | xapp  |     | submgr  |    | e2term  |
1244 // +-------+     +---------+    +---------+
1245 //     |              |              |
1246 //     | SubReq       |              |
1247 //     |------------->|              |
1248 //     |              |              |
1249 //     |              | SubReq       |
1250 //     |              |------------->|
1251 //     |              |              |
1252 //     |              |      SubResp |
1253 //     |              |<-------------|
1254 //     |              |              |
1255 //     |      SubResp |              |
1256 //     |<-------------|              |
1257 //     |              |              |
1258 //     | SubReq       |              |
1259 //     |------------->|              |
1260 //     |              |              |
1261 //     |              | SubReq       |
1262 //     |              |------------->|
1263 //     |              |              |
1264 //     |              |      SubResp |
1265 //     |              |<-------------|
1266 //     |              |              |
1267 //     |      SubResp |              |
1268 //     |<-------------|              |
1269 //     |              |              |
1270 //     | SubDelReq    |              |
1271 //     |------------->|              |
1272 //     |              |              |
1273 //     |              | SubDelReq    |
1274 //     |              |------------->|
1275 //     |              |              |
1276 //     |              |   SubDelResp |
1277 //     |              |<-------------|
1278 //     |              |              |
1279 //     |   SubDelResp |              |
1280 //     |<-------------|              |
1281 //
1282 //-----------------------------------------------------------------------------
1283
1284 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
1285         CaseBegin("TestSubReqAndSubDelOk")
1286
1287         rparams1 := &teststube2ap.E2StubSubsReqParams{}
1288         rparams1.Init()
1289         rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1290         cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1291
1292         crereq, cremsg := e2termConn1.RecvSubsReq(t)
1293         e2termConn1.SendSubsResp(t, crereq, cremsg)
1294         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1295
1296         //Policy change
1297         rparams1.Req.RequestId.Seq = e2SubsId
1298         rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
1299         xappConn1.SendSubsReq(t, rparams1, cretrans)
1300
1301         crereq, cremsg = e2termConn1.RecvSubsReq(t)
1302         e2termConn1.SendSubsResp(t, crereq, cremsg)
1303         e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1304         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1305         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1306
1307         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1308         xappConn1.RecvSubsDelResp(t, deltrans)
1309
1310         //Wait that subs is cleaned
1311         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1312
1313         xappConn1.TestMsgChanEmpty(t)
1314         xappConn2.TestMsgChanEmpty(t)
1315         e2termConn1.TestMsgChanEmpty(t)
1316         mainCtrl.wait_registry_empty(t, 10)
1317 }
1318
1319 //-----------------------------------------------------------------------------
1320 // TestSubReqAndSubDelOkTwoE2termParallel
1321 //
1322 //   stub                          stub           stub
1323 // +-------+     +---------+    +---------+    +---------+
1324 // | xapp  |     | submgr  |    | e2term1 |    | e2term2 |
1325 // +-------+     +---------+    +---------+    +---------+
1326 //     |              |              |              |
1327 //     |              |              |              |
1328 //     |              |              |              |
1329 //     | SubReq1      |              |              |
1330 //     |------------->|              |              |
1331 //     |              |              |              |
1332 //     |              | SubReq1      |              |
1333 //     |              |------------->|              |
1334 //     |              |              |              |
1335 //     | SubReq2      |              |              |
1336 //     |------------->|              |              |
1337 //     |              |              |              |
1338 //     |              | SubReq2      |              |
1339 //     |              |---------------------------->|
1340 //     |              |              |              |
1341 //     |              |    SubResp1  |              |
1342 //     |              |<-------------|              |
1343 //     |    SubResp1  |              |              |
1344 //     |<-------------|              |              |
1345 //     |              |    SubResp2  |              |
1346 //     |              |<----------------------------|
1347 //     |    SubResp2  |              |              |
1348 //     |<-------------|              |              |
1349 //     |              |              |              |
1350 //     |        [SUBS 1 DELETE]      |              |
1351 //     |              |              |              |
1352 //     |        [SUBS 2 DELETE]      |              |
1353 //     |              |              |              |
1354 //
1355 //-----------------------------------------------------------------------------
1356 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
1357         CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
1358
1359         //Req1
1360         cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1361         xappConn1.SendSubsReq(t, nil, cretrans1)
1362         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1363
1364         cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
1365         xappConn1.SendSubsReq(t, nil, cretrans2)
1366         crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
1367
1368         //Resp1
1369         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1370         e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1371
1372         //Resp2
1373         e2termConn2.SendSubsResp(t, crereq2, cremsg2)
1374         e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1375
1376         //Del1
1377         deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1378         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1379         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1380         xappConn1.RecvSubsDelResp(t, deltrans1)
1381         //Wait that subs is cleaned
1382         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1383
1384         //Del2
1385         deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
1386         delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
1387         e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
1388         xappConn1.RecvSubsDelResp(t, deltrans2)
1389         //Wait that subs is cleaned
1390         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1391
1392         xappConn1.TestMsgChanEmpty(t)
1393         xappConn2.TestMsgChanEmpty(t)
1394         e2termConn1.TestMsgChanEmpty(t)
1395         e2termConn2.TestMsgChanEmpty(t)
1396         mainCtrl.wait_registry_empty(t, 10)
1397 }