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.InstanceId, 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.InstanceId, 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 //     |              | SubDelReq    |
 676 //     |              |------------->|
 677 //     |              |              |
 678 //     |              |   SubDelResp |
 679 //     |              |<-------------|
 680 //     |              |              |
 681 //     |      SubFail |              |
 682 //     |<-------------|              |
 683 //     |              |              |
 684 //
 685 //-----------------------------------------------------------------------------
 686
 687 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
 688
 689         CaseBegin("TestSubReqSubFailRespInSubmgr start")
 690
 691         // Xapp: Send SubsReq
 692         cretrans := xappConn1.SendSubsReq(t, nil, nil)
 693
 694         // E2t: Receive SubsReq and send SubsFail (first)
 695         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
 696         fparams1 := &teststube2ap.E2StubSubsFailParams{}
 697         fparams1.Set(crereq1)
 698         e2termConn1.SendSubsFail(t, fparams1, cremsg1)
 699
 700         // E2t: Receive SubsDelReq and send SubsDelResp (internal first)
 701         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
 702         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
 703
 704         // Xapp: Receive SubsFail
 705         e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
 706
 707         // Wait that subs is cleaned
 708         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 709
 710         xappConn1.TestMsgChanEmpty(t)
 711         xappConn2.TestMsgChanEmpty(t)
 712         e2termConn1.TestMsgChanEmpty(t)
 713         mainCtrl.wait_registry_empty(t, 10)
 714 }
 715
 716 //-----------------------------------------------------------------------------
 717 // TestSubReqSubFailRespInSubmgrWithDuplicate
 718 //
 719 //   stub                          stub
 720 // +-------+     +---------+    +---------+
 721 // | xapp  |     | submgr  |    | e2term  |
 722 // +-------+     +---------+    +---------+
 723 //     |              |              |
 724 //     |  SubReq      |              |
 725 //     |------------->|              |
 726 //     |              |              |
 727 //     |              | SubReq       |
 728 //     |              |------------->|
 729 //     |              |              |
 730 //     |              |      SubFail |
 731 //     |              |<-------------|
 732 //     |              |              |
 733 //     |              | SubDelReq    |
 734 //     |              |------------->|
 735 //     |              |              |
 736 //     |              |   SubDelResp |
 737 //     |              |<-------------|
 738 //     |              |              |
 739 //     |              | SubReq       |
 740 //     |              |------------->|
 741 //     |              |              |
 742 //     |              |      SubResp |
 743 //     |              |<-------------|
 744 //     |              |              |
 745 //     |      SubResp |              |
 746 //     |<-------------|              |
 747 //     |              |              |
 748 //     |         [SUBS DELETE]       |
 749 //     |              |              |
 750 //
 751 //-----------------------------------------------------------------------------
 752
 753 func TestSubReqSubFailRespInSubmgrWithDuplicate(t *testing.T) {
 754
 755         CaseBegin("TestSubReqSubFailRespInSubmgrWithDuplicate start")
 756
 757         // Xapp: Send SubsReq
 758         cretrans := xappConn1.SendSubsReq(t, nil, nil)
 759
 760         // E2t: Receive SubsReq and send SubsFail (first)
 761         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
 762         fparams1 := &teststube2ap.E2StubSubsFailParams{}
 763         fparams1.Set(crereq1)
 764         fparams1.SetCauseVal(-1, 5, 3)
 765         e2termConn1.SendSubsFail(t, fparams1, cremsg1)
 766
 767         // E2t: Receive SubsDelReq and send SubsDelResp (internal)
 768         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
 769         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
 770
 771         // E2t: Receive SubsReq and send SubsResp (second)
 772         crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
 773         e2termConn1.SendSubsResp(t, crereq2, cremsg2)
 774
 775         // XAPP: Receive SubsResp
 776         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
 777
 778         // Delete
 779         deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
 780         delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
 781         e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
 782         xappConn1.RecvSubsDelResp(t, deltrans2)
 783
 784         // Wait that subs is cleaned
 785         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 786
 787         xappConn1.TestMsgChanEmpty(t)
 788         xappConn2.TestMsgChanEmpty(t)
 789         e2termConn1.TestMsgChanEmpty(t)
 790         mainCtrl.wait_registry_empty(t, 10)
 791 }
 792
 793 //-----------------------------------------------------------------------------
 794 // TestSubReqSubFailRespInSubmgrWithDuplicateFail
 795 //
 796 //   stub                          stub
 797 // +-------+     +---------+    +---------+
 798 // | xapp  |     | submgr  |    | e2term  |
 799 // +-------+     +---------+    +---------+
 800 //     |              |              |
 801 //     |  SubReq      |              |
 802 //     |------------->|              |
 803 //     |              |              |
 804 //     |              | SubReq       |
 805 //     |              |------------->|
 806 //     |              |              |
 807 //     |              |      SubFail |
 808 //     |              |<-------------|
 809 //     |              |              |
 810 //     |              | SubDelReq    |
 811 //     |              |------------->|
 812 //     |              |              |
 813 //     |              |   SubDelResp |
 814 //     |              |<-------------|
 815 //     |              |              |
 816 //     |              | SubReq       |
 817 //     |              |------------->|
 818 //     |              |              |
 819 //     |              |      SubFail |
 820 //     |              |<-------------|
 821 //     |              |              |
 822 //     |              | SubDelReq    |
 823 //     |              |------------->|
 824 //     |              |              |
 825 //     |              |   SubDelResp |
 826 //     |              |<-------------|
 827 //     |      SubFail |              |
 828 //     |<-------------|              |
 829 //     |              |              |
 830 //
 831 //-----------------------------------------------------------------------------
 832
 833 func TestSubReqSubFailRespInSubmgrWithDuplicateFail(t *testing.T) {
 834
 835         CaseBegin("TestSubReqSubFailRespInSubmgrWithDuplicateFail start")
 836
 837         // Xapp: Send SubsReq
 838         cretrans := xappConn1.SendSubsReq(t, nil, nil)
 839
 840         // E2t: Receive SubsReq and send SubsFail (first)
 841         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
 842         fparams1 := &teststube2ap.E2StubSubsFailParams{}
 843         fparams1.Set(crereq1)
 844         fparams1.SetCauseVal(-1, 5, 3)
 845         e2termConn1.SendSubsFail(t, fparams1, cremsg1)
 846
 847         // E2t: Receive SubsDelReq and send SubsDelResp (internal first)
 848         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
 849         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
 850
 851         // E2t: Receive SubsReq and send SubsFail (second)
 852         crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
 853         fparams2 := &teststube2ap.E2StubSubsFailParams{}
 854         fparams2.Set(crereq2)
 855         fparams2.SetCauseVal(-1, 5, 3)
 856         e2termConn1.SendSubsFail(t, fparams2, cremsg2)
 857
 858         // E2t: Receive SubsDelReq and send SubsDelResp (internal second)
 859         delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
 860         e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
 861
 862         // Xapp: Receive SubsFail
 863         e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
 864
 865         // Wait that subs is cleaned
 866         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 867
 868         xappConn1.TestMsgChanEmpty(t)
 869         xappConn2.TestMsgChanEmpty(t)
 870         e2termConn1.TestMsgChanEmpty(t)
 871         mainCtrl.wait_registry_empty(t, 10)
 872 }
 873
 874 //-----------------------------------------------------------------------------
 875 // TestSubDelReqRetryInSubmgr
 876 //
 877 //   stub                          stub
 878 // +-------+     +---------+    +---------+
 879 // | xapp  |     | submgr  |    | e2term  |
 880 // +-------+     +---------+    +---------+
 881 //     |              |              |
 882 //     |         [SUBS CREATE]       |
 883 //     |              |              |
 884 //     |              |              |
 885 //     | SubDelReq    |              |
 886 //     |------------->|              |
 887 //     |              |              |
 888 //     |              | SubDelReq    |
 889 //     |              |------------->|
 890 //     |              |              |
 891 //     |              | SubDelReq    |
 892 //     |              |------------->|
 893 //     |              |              |
 894 //     |              |   SubDelResp |
 895 //     |              |<-------------|
 896 //     |              |              |
 897 //     |   SubDelResp |              |
 898 //     |<-------------|              |
 899 //
 900 //-----------------------------------------------------------------------------
 901
 902 func TestSubDelReqRetryInSubmgr(t *testing.T) {
 903
 904         CaseBegin("TestSubDelReqRetryInSubmgr start")
 905
 906         // Subs Create
 907         cretrans := xappConn1.SendSubsReq(t, nil, nil)
 908         crereq, cremsg := e2termConn1.RecvSubsReq(t)
 909         e2termConn1.SendSubsResp(t, crereq, cremsg)
 910         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
 911
 912         // Subs Delete
 913         // Xapp: Send SubsDelReq
 914         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
 915
 916         // E2t: Receive 1st SubsDelReq
 917         e2termConn1.RecvSubsDelReq(t)
 918
 919         // E2t: Receive 2nd SubsDelReq and send SubsDelResp
 920         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
 921         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
 922
 923         // Xapp: Receive SubsDelResp
 924         xappConn1.RecvSubsDelResp(t, deltrans)
 925
 926         // Wait that subs is cleaned
 927         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 928
 929         xappConn1.TestMsgChanEmpty(t)
 930         xappConn2.TestMsgChanEmpty(t)
 931         e2termConn1.TestMsgChanEmpty(t)
 932         mainCtrl.wait_registry_empty(t, 10)
 933 }
 934
 935 //-----------------------------------------------------------------------------
 936 // TestSubDelReqTwoRetriesNoRespInSubmgr
 937 //
 938 //   stub                          stub
 939 // +-------+     +---------+    +---------+
 940 // | xapp  |     | submgr  |    | e2term  |
 941 // +-------+     +---------+    +---------+
 942 //     |              |              |
 943 //     |         [SUBS CREATE]       |
 944 //     |              |              |
 945 //     |              |              |
 946 //     | SubDelReq    |              |
 947 //     |------------->|              |
 948 //     |              |              |
 949 //     |              | SubDelReq    |
 950 //     |              |------------->|
 951 //     |              |              |
 952 //     |              | SubDelReq    |
 953 //     |              |------------->|
 954 //     |              |              |
 955 //     |              |              |
 956 //     |   SubDelResp |              |
 957 //     |<-------------|              |
 958 //
 959 //-----------------------------------------------------------------------------
 960
 961 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
 962
 963         CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
 964
 965         // Subs Create
 966         cretrans := xappConn1.SendSubsReq(t, nil, nil)
 967         crereq, cremsg := e2termConn1.RecvSubsReq(t)
 968         e2termConn1.SendSubsResp(t, crereq, cremsg)
 969         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
 970
 971         // Subs Delete
 972         // Xapp: Send SubsDelReq
 973         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
 974
 975         // E2t: Receive 1st SubsDelReq
 976         e2termConn1.RecvSubsDelReq(t)
 977
 978         // E2t: Receive 2nd SubsDelReq
 979         e2termConn1.RecvSubsDelReq(t)
 980
 981         // Xapp: Receive SubsDelResp
 982         xappConn1.RecvSubsDelResp(t, deltrans)
 983
 984         // Wait that subs is cleaned
 985         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 986
 987         xappConn1.TestMsgChanEmpty(t)
 988         xappConn2.TestMsgChanEmpty(t)
 989         e2termConn1.TestMsgChanEmpty(t)
 990         mainCtrl.wait_registry_empty(t, 10)
 991 }
 992
 993 //-----------------------------------------------------------------------------
 994 // TestSubDelReqSubDelFailRespInSubmgr
 995 //
 996 //   stub                          stub
 997 // +-------+     +---------+    +---------+
 998 // | xapp  |     | submgr  |    | e2term  |
 999 // +-------+     +---------+    +---------+
1000 //     |              |              |
1001 //     |         [SUBS CREATE]       |
1002 //     |              |              |
1003 //     |              |              |
1004 //     |  SubDelReq   |              |
1005 //     |------------->|              |
1006 //     |              |              |
1007 //     |              | SubDelReq    |
1008 //     |              |------------->|
1009 //     |              |              |
1010 //     |              |   SubDelFail |
1011 //     |              |<-------------|
1012 //     |              |              |
1013 //     |   SubDelResp |              |
1014 //     |<-------------|              |
1015 //     |              |              |
1016 //
1017 //-----------------------------------------------------------------------------
1018
1019 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1020
1021         CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1022
1023         // Subs Create
1024         cretrans := xappConn1.SendSubsReq(t, nil, nil)
1025         crereq, cremsg := e2termConn1.RecvSubsReq(t)
1026         e2termConn1.SendSubsResp(t, crereq, cremsg)
1027         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1028
1029         // Xapp: Send SubsDelReq
1030         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1031
1032         // E2t: Send receive SubsDelReq and send SubsDelFail
1033         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1034         e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1035
1036         // Xapp: Receive SubsDelResp
1037         xappConn1.RecvSubsDelResp(t, deltrans)
1038
1039         // Wait that subs is cleaned
1040         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1041
1042         xappConn1.TestMsgChanEmpty(t)
1043         xappConn2.TestMsgChanEmpty(t)
1044         e2termConn1.TestMsgChanEmpty(t)
1045         mainCtrl.wait_registry_empty(t, 10)
1046 }
1047
1048 //-----------------------------------------------------------------------------
1049 // TestSubReqAndSubDelOkSameAction
1050 //
1051 //   stub                          stub
1052 // +-------+     +-------+     +---------+    +---------+
1053 // | xapp2 |     | xapp1 |     | submgr  |    | e2term  |
1054 // +-------+     +-------+     +---------+    +---------+
1055 //     |             |              |              |
1056 //     |             |              |              |
1057 //     |             |              |              |
1058 //     |             | SubReq1      |              |
1059 //     |             |------------->|              |
1060 //     |             |              |              |
1061 //     |             |              | SubReq1      |
1062 //     |             |              |------------->|
1063 //     |             |              |    SubResp1  |
1064 //     |             |              |<-------------|
1065 //     |             |    SubResp1  |              |
1066 //     |             |<-------------|              |
1067 //     |             |              |              |
1068 //     |          SubReq2           |              |
1069 //     |--------------------------->|              |
1070 //     |             |              |              |
1071 //     |          SubResp2          |              |
1072 //     |<---------------------------|              |
1073 //     |             |              |              |
1074 //     |             | SubDelReq 1  |              |
1075 //     |             |------------->|              |
1076 //     |             |              |              |
1077 //     |             | SubDelResp 1 |              |
1078 //     |             |<-------------|              |
1079 //     |             |              |              |
1080 //     |         SubDelReq 2        |              |
1081 //     |--------------------------->|              |
1082 //     |             |              |              |
1083 //     |             |              | SubDelReq 2  |
1084 //     |             |              |------------->|
1085 //     |             |              |              |
1086 //     |             |              | SubDelReq 2  |
1087 //     |             |              |------------->|
1088 //     |             |              |              |
1089 //     |         SubDelResp 2       |              |
1090 //     |<---------------------------|              |
1091 //
1092 //-----------------------------------------------------------------------------
1093 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
1094         CaseBegin("TestSubReqAndSubDelOkSameAction")
1095
1096         //Req1
1097         rparams1 := &teststube2ap.E2StubSubsReqParams{}
1098         rparams1.Init()
1099         cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1100         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1101         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1102         e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1103
1104         //Req2
1105         rparams2 := &teststube2ap.E2StubSubsReqParams{}
1106         rparams2.Init()
1107         cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1108         //crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1109         //e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1110         e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1111
1112         resp, _ := xapp.Subscription.QuerySubscriptions()
1113         assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1114         assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1115         assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560", "localhost:13660"})
1116
1117         //Del1
1118         deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1119         //e2termConn1.RecvSubsDelReq(t)
1120         //e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1121         xappConn1.RecvSubsDelResp(t, deltrans1)
1122         //Wait that subs is cleaned
1123         //mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1124
1125         //Del2
1126         deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1127         delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1128         e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1129         xappConn2.RecvSubsDelResp(t, deltrans2)
1130         //Wait that subs is cleaned
1131         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1132
1133         xappConn1.TestMsgChanEmpty(t)
1134         xappConn2.TestMsgChanEmpty(t)
1135         e2termConn1.TestMsgChanEmpty(t)
1136         mainCtrl.wait_registry_empty(t, 10)
1137 }
1138
1139 //-----------------------------------------------------------------------------
1140 // TestSubReqAndSubDelOkSameActionParallel
1141 //
1142 //   stub          stub                          stub
1143 // +-------+     +-------+     +---------+    +---------+
1144 // | xapp2 |     | xapp1 |     | submgr  |    | e2term  |
1145 // +-------+     +-------+     +---------+    +---------+
1146 //     |             |              |              |
1147 //     |             |              |              |
1148 //     |             |              |              |
1149 //     |             | SubReq1      |              |
1150 //     |             |------------->|              |
1151 //     |             |              |              |
1152 //     |             |              | SubReq1      |
1153 //     |             |              |------------->|
1154 //     |          SubReq2           |              |
1155 //     |--------------------------->|              |
1156 //     |             |              |    SubResp1  |
1157 //     |             |              |<-------------|
1158 //     |             |    SubResp1  |              |
1159 //     |             |<-------------|              |
1160 //     |             |              |              |
1161 //     |          SubResp2          |              |
1162 //     |<---------------------------|              |
1163 //     |             |              |              |
1164 //     |             | SubDelReq 1  |              |
1165 //     |             |------------->|              |
1166 //     |             |              |              |
1167 //     |             | SubDelResp 1 |              |
1168 //     |             |<-------------|              |
1169 //     |             |              |              |
1170 //     |         SubDelReq 2        |              |
1171 //     |--------------------------->|              |
1172 //     |             |              |              |
1173 //     |             |              | SubDelReq 2  |
1174 //     |             |              |------------->|
1175 //     |             |              |              |
1176 //     |             |              | SubDelReq 2  |
1177 //     |             |              |------------->|
1178 //     |             |              |              |
1179 //     |         SubDelResp 2       |              |
1180 //     |<---------------------------|              |
1181 //
1182 //-----------------------------------------------------------------------------
1183 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1184         CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1185
1186         //Req1
1187         rparams1 := &teststube2ap.E2StubSubsReqParams{}
1188         rparams1.Init()
1189         cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1190         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1191
1192         //Req2
1193         rparams2 := &teststube2ap.E2StubSubsReqParams{}
1194         rparams2.Init()
1195         cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1196
1197         //Resp1
1198         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1199         e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1200
1201         //Resp2
1202         e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1203
1204         //Del1
1205         deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1206         xappConn1.RecvSubsDelResp(t, deltrans1)
1207
1208         //Del2
1209         deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1210         delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1211         e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1212         xappConn2.RecvSubsDelResp(t, deltrans2)
1213
1214         //Wait that subs is cleaned
1215         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1216
1217         xappConn1.TestMsgChanEmpty(t)
1218         xappConn2.TestMsgChanEmpty(t)
1219         e2termConn1.TestMsgChanEmpty(t)
1220         mainCtrl.wait_registry_empty(t, 10)
1221 }
1222
1223 //-----------------------------------------------------------------------------
1224 // TestSubReqAndSubDelNokSameActionParallel
1225 //
1226 //   stub          stub                          stub
1227 // +-------+     +-------+     +---------+    +---------+
1228 // | xapp2 |     | xapp1 |     | submgr  |    | e2term  |
1229 // +-------+     +-------+     +---------+    +---------+
1230 //     |             |              |              |
1231 //     |             |              |              |
1232 //     |             |              |              |
1233 //     |             | SubReq1      |              |
1234 //     |             |------------->|              |
1235 //     |             |              |              |
1236 //     |             |              | SubReq1      |
1237 //     |             |              |------------->|
1238 //     |          SubReq2           |              |
1239 //     |--------------------------->|              |
1240 //     |             |              |    SubFail1  |
1241 //     |             |              |<-------------|
1242 //     |             |              |              |
1243 //     |             |              | SubDelReq    |
1244 //     |             |              |------------->|
1245 //     |             |              |   SubDelResp |
1246 //     |             |              |<-------------|
1247 //     |             |              |              |
1248 //     |             |    SubFail1  |              |
1249 //     |             |<-------------|              |
1250 //     |             |              |              |
1251 //     |          SubFail2          |              |
1252 //     |<---------------------------|              |
1253 //
1254 //-----------------------------------------------------------------------------
1255 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1256         CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1257
1258         //Req1
1259         rparams1 := &teststube2ap.E2StubSubsReqParams{}
1260         rparams1.Init()
1261         cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1262
1263         // E2t: Receive SubsReq (first)
1264         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1265
1266         //Req2
1267         rparams2 := &teststube2ap.E2StubSubsReqParams{}
1268         rparams2.Init()
1269         seqBef2 := mainCtrl.get_msgcounter(t)
1270         cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1271         mainCtrl.wait_msgcounter_change(t, seqBef2, 10)
1272
1273         // E2t: send SubsFail (first)
1274         fparams1 := &teststube2ap.E2StubSubsFailParams{}
1275         fparams1.Set(crereq1)
1276         e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1277
1278         // E2t: internal delete
1279         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1280         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1281
1282         //Fail1
1283         e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1284         //Fail2
1285         xappConn2.RecvSubsFail(t, cretrans2)
1286
1287         //Wait that subs is cleaned
1288         mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1289
1290         xappConn1.TestMsgChanEmpty(t)
1291         xappConn2.TestMsgChanEmpty(t)
1292         e2termConn1.TestMsgChanEmpty(t)
1293         mainCtrl.wait_registry_empty(t, 10)
1294 }
1295
1296 //-----------------------------------------------------------------------------
1297 // TestSubReqAndSubDelNoAnswerSameActionParallel
1298 //
1299 //   stub          stub                          stub
1300 // +-------+     +-------+     +---------+    +---------+
1301 // | xapp2 |     | xapp1 |     | submgr  |    | e2term  |
1302 // +-------+     +-------+     +---------+    +---------+
1303 //     |             |              |              |
1304 //     |             |              |              |
1305 //     |             |              |              |
1306 //     |             | SubReq1      |              |
1307 //     |             |------------->|              |
1308 //     |             |              |              |
1309 //     |             |              | SubReq1      |
1310 //     |             |              |------------->|
1311 //     |             | SubReq2      |              |
1312 //     |--------------------------->|              |
1313 //     |             |              |              |
1314 //     |             |              | SubReq1      |
1315 //     |             |              |------------->|
1316 //     |             |              |              |
1317 //     |             |              |              |
1318 //     |             |              | SubDelReq    |
1319 //     |             |              |------------->|
1320 //     |             |              |              |
1321 //     |             |              |   SubDelResp |
1322 //     |             |              |<-------------|
1323 //
1324 //-----------------------------------------------------------------------------
1325 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1326         CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1327
1328         //Req1
1329         rparams1 := &teststube2ap.E2StubSubsReqParams{}
1330         rparams1.Init()
1331         xappConn1.SendSubsReq(t, rparams1, nil)
1332
1333         e2termConn1.RecvSubsReq(t)
1334
1335         //Req2
1336         rparams2 := &teststube2ap.E2StubSubsReqParams{}
1337         rparams2.Init()
1338         seqBef2 := mainCtrl.get_msgcounter(t)
1339         xappConn2.SendSubsReq(t, rparams2, nil)
1340         mainCtrl.wait_msgcounter_change(t, seqBef2, 10)
1341
1342         //Req1 (retransmitted)
1343         e2termConn1.RecvSubsReq(t)
1344
1345         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1346         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1347
1348         //Wait that subs is cleaned
1349         mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10)
1350
1351         xappConn1.TestMsgChanEmpty(t)
1352         xappConn2.TestMsgChanEmpty(t)
1353         e2termConn1.TestMsgChanEmpty(t)
1354         mainCtrl.wait_registry_empty(t, 15)
1355 }
1356
1357 //-----------------------------  Policy cases ---------------------------------
1358 //-----------------------------------------------------------------------------
1359 // TestSubReqPolicyAndSubDelOk
1360 //
1361 //   stub                          stub
1362 // +-------+     +---------+    +---------+
1363 // | xapp  |     | submgr  |    | e2term  |
1364 // +-------+     +---------+    +---------+
1365 //     |              |              |
1366 //     | SubReq       |              |
1367 //     |------------->|              |
1368 //     |              |              |
1369 //     |              | SubReq       |
1370 //     |              |------------->|
1371 //     |              |              |
1372 //     |              |      SubResp |
1373 //     |              |<-------------|
1374 //     |              |              |
1375 //     |      SubResp |              |
1376 //     |<-------------|              |
1377 //     |              |              |
1378 //     |              |              |
1379 //     | SubDelReq    |              |
1380 //     |------------->|              |
1381 //     |              |              |
1382 //     |              | SubDelReq    |
1383 //     |              |------------->|
1384 //     |              |              |
1385 //     |              |   SubDelResp |
1386 //     |              |<-------------|
1387 //     |              |              |
1388 //     |   SubDelResp |              |
1389 //     |<-------------|              |
1390 //
1391 //-----------------------------------------------------------------------------
1392 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
1393         CaseBegin("TestSubReqAndSubDelOk")
1394
1395         rparams1 := &teststube2ap.E2StubSubsReqParams{}
1396         rparams1.Init()
1397         rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1398         cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1399
1400         crereq, cremsg := e2termConn1.RecvSubsReq(t)
1401         e2termConn1.SendSubsResp(t, crereq, cremsg)
1402         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1403         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1404         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1405
1406         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1407         xappConn1.RecvSubsDelResp(t, deltrans)
1408
1409         //Wait that subs is cleaned
1410         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1411
1412         xappConn1.TestMsgChanEmpty(t)
1413         xappConn2.TestMsgChanEmpty(t)
1414         e2termConn1.TestMsgChanEmpty(t)
1415         mainCtrl.wait_registry_empty(t, 10)
1416 }
1417
1418 //-----------------------------------------------------------------------------
1419 // TestSubReqPolicyChangeAndSubDelOk
1420 //
1421 //   stub                          stub
1422 // +-------+     +---------+    +---------+
1423 // | xapp  |     | submgr  |    | e2term  |
1424 // +-------+     +---------+    +---------+
1425 //     |              |              |
1426 //     | SubReq       |              |
1427 //     |------------->|              |
1428 //     |              |              |
1429 //     |              | SubReq       |
1430 //     |              |------------->|
1431 //     |              |              |
1432 //     |              |      SubResp |
1433 //     |              |<-------------|
1434 //     |              |              |
1435 //     |      SubResp |              |
1436 //     |<-------------|              |
1437 //     |              |              |
1438 //     | SubReq       |              |
1439 //     |------------->|              |
1440 //     |              |              |
1441 //     |              | SubReq       |
1442 //     |              |------------->|
1443 //     |              |              |
1444 //     |              |      SubResp |
1445 //     |              |<-------------|
1446 //     |              |              |
1447 //     |      SubResp |              |
1448 //     |<-------------|              |
1449 //     |              |              |
1450 //     | SubDelReq    |              |
1451 //     |------------->|              |
1452 //     |              |              |
1453 //     |              | SubDelReq    |
1454 //     |              |------------->|
1455 //     |              |              |
1456 //     |              |   SubDelResp |
1457 //     |              |<-------------|
1458 //     |              |              |
1459 //     |   SubDelResp |              |
1460 //     |<-------------|              |
1461 //
1462 //-----------------------------------------------------------------------------
1463
1464 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
1465         CaseBegin("TestSubReqAndSubDelOk")
1466
1467         rparams1 := &teststube2ap.E2StubSubsReqParams{}
1468         rparams1.Init()
1469         rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1470         cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1471
1472         crereq, cremsg := e2termConn1.RecvSubsReq(t)
1473         e2termConn1.SendSubsResp(t, crereq, cremsg)
1474         e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1475
1476         //Policy change
1477         rparams1.Req.RequestId.InstanceId = e2SubsId
1478         rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
1479         xappConn1.SendSubsReq(t, rparams1, cretrans)
1480
1481         crereq, cremsg = e2termConn1.RecvSubsReq(t)
1482         e2termConn1.SendSubsResp(t, crereq, cremsg)
1483         e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1484         deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1485         delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1486
1487         e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1488         xappConn1.RecvSubsDelResp(t, deltrans)
1489
1490         //Wait that subs is cleaned
1491         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1492
1493         xappConn1.TestMsgChanEmpty(t)
1494         xappConn2.TestMsgChanEmpty(t)
1495         e2termConn1.TestMsgChanEmpty(t)
1496         mainCtrl.wait_registry_empty(t, 10)
1497 }
1498
1499 //-----------------------------------------------------------------------------
1500 // TestSubReqAndSubDelOkTwoE2termParallel
1501 //
1502 //   stub                          stub           stub
1503 // +-------+     +---------+    +---------+    +---------+
1504 // | xapp  |     | submgr  |    | e2term1 |    | e2term2 |
1505 // +-------+     +---------+    +---------+    +---------+
1506 //     |              |              |              |
1507 //     |              |              |              |
1508 //     |              |              |              |
1509 //     | SubReq1      |              |              |
1510 //     |------------->|              |              |
1511 //     |              |              |              |
1512 //     |              | SubReq1      |              |
1513 //     |              |------------->|              |
1514 //     |              |              |              |
1515 //     | SubReq2      |              |              |
1516 //     |------------->|              |              |
1517 //     |              |              |              |
1518 //     |              | SubReq2      |              |
1519 //     |              |---------------------------->|
1520 //     |              |              |              |
1521 //     |              |    SubResp1  |              |
1522 //     |              |<-------------|              |
1523 //     |    SubResp1  |              |              |
1524 //     |<-------------|              |              |
1525 //     |              |    SubResp2  |              |
1526 //     |              |<----------------------------|
1527 //     |    SubResp2  |              |              |
1528 //     |<-------------|              |              |
1529 //     |              |              |              |
1530 //     |        [SUBS 1 DELETE]      |              |
1531 //     |              |              |              |
1532 //     |        [SUBS 2 DELETE]      |              |
1533 //     |              |              |              |
1534 //
1535 //-----------------------------------------------------------------------------
1536 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
1537         CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
1538
1539         //Req1
1540         cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1541         xappConn1.SendSubsReq(t, nil, cretrans1)
1542         crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1543
1544         cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
1545         xappConn1.SendSubsReq(t, nil, cretrans2)
1546         crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
1547
1548         //Resp1
1549         e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1550         e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1551
1552         //Resp2
1553         e2termConn2.SendSubsResp(t, crereq2, cremsg2)
1554         e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1555
1556         //Del1
1557         deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1558         delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1559         e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1560         xappConn1.RecvSubsDelResp(t, deltrans1)
1561         //Wait that subs is cleaned
1562         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1563
1564         //Del2
1565         deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
1566         delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
1567         e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
1568         xappConn1.RecvSubsDelResp(t, deltrans2)
1569         //Wait that subs is cleaned
1570         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1571
1572         xappConn1.TestMsgChanEmpty(t)
1573         xappConn2.TestMsgChanEmpty(t)
1574         e2termConn1.TestMsgChanEmpty(t)
1575         e2termConn2.TestMsgChanEmpty(t)
1576         mainCtrl.wait_registry_empty(t, 10)
1577 }