pkg/control/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/e2ap/pkg/e2ap_wrapper"
  25         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/packer"
  26         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
  27         "testing"
  28         "time"
  29 )
  30
  31 //-----------------------------------------------------------------------------
  32 //
  33 //-----------------------------------------------------------------------------
  34 var e2asnpacker e2ap.E2APPackerIf = e2ap_wrapper.NewAsn1E2Packer()
  35
  36 //-----------------------------------------------------------------------------
  37 //
  38 //-----------------------------------------------------------------------------
  39 func (xappConn *testingXappControl) handle_xapp_subs_req(t *testing.T, oldTrans *xappTransaction) *xappTransaction {
  40         xapp.Logger.Info("handle_xapp_subs_req")
  41         e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest()
  42
  43         //---------------------------------
  44         // xapp activity: Send Subs Req
  45         //---------------------------------
  46         xapp.Logger.Info("(%s) Send Subs Req", xappConn.desc)
  47
  48         req := &e2ap.E2APSubscriptionRequest{}
  49
  50         req.RequestId.Id = 1
  51         req.RequestId.Seq = 0
  52         req.FunctionId = 1
  53
  54         req.EventTriggerDefinition.InterfaceId.GlobalEnbId.Present = true
  55         req.EventTriggerDefinition.InterfaceId.GlobalEnbId.PlmnIdentity.StringPut("310150")
  56         req.EventTriggerDefinition.InterfaceId.GlobalEnbId.NodeId.Id = 123
  57         req.EventTriggerDefinition.InterfaceId.GlobalEnbId.NodeId.Bits = e2ap.E2AP_ENBIDHomeBits28
  58
  59         // gnb -> enb outgoing
  60         // enb -> gnb incoming
  61         // X2 36423-f40.doc
  62         req.EventTriggerDefinition.InterfaceDirection = e2ap.E2AP_InterfaceDirectionIncoming
  63         req.EventTriggerDefinition.ProcedureCode = 5 //28 35
  64         req.EventTriggerDefinition.TypeOfMessage = e2ap.E2AP_InitiatingMessage
  65
  66         req.ActionSetups = make([]e2ap.ActionToBeSetupItem, 1)
  67         req.ActionSetups[0].ActionId = 0
  68         req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeReport
  69         req.ActionSetups[0].ActionDefinition.Present = false
  70         //req.ActionSetups[index].ActionDefinition.StyleId = 255
  71         //req.ActionSetups[index].ActionDefinition.ParamId = 222
  72         req.ActionSetups[0].SubsequentAction.Present = true
  73         req.ActionSetups[0].SubsequentAction.Type = e2ap.E2AP_SubSeqActionTypeContinue
  74         req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitZero
  75
  76         e2SubsReq.Set(req)
  77         xapp.Logger.Debug("%s", e2SubsReq.String())
  78         err, packedMsg := e2SubsReq.Pack(nil)
  79         if err != nil {
  80                 testError(t, "(%s) pack NOK %s", xappConn.desc, err.Error())
  81                 return nil
  82         }
  83
  84         var trans *xappTransaction = oldTrans
  85         if trans == nil {
  86                 trans = xappConn.newXappTransaction(nil, "RAN_NAME_1")
  87         }
  88
  89         params := &xapp.RMRParams{}
  90         params.Mtype = xapp.RIC_SUB_REQ
  91         params.SubId = -1
  92         params.Payload = packedMsg.Buf
  93         params.Meid = trans.meid
  94         params.Xid = trans.xid
  95         params.Mbuf = nil
  96
  97         snderr := xappConn.RmrSend(params)
  98         if snderr != nil {
  99                 testError(t, "(%s) RMR SEND FAILED: %s", xappConn.desc, snderr.Error())
 100                 return nil
 101         }
 102         return trans
 103 }
 104
 105 //-----------------------------------------------------------------------------
 106 //
 107 //-----------------------------------------------------------------------------
 108 func (xappConn *testingXappControl) handle_xapp_subs_resp(t *testing.T, trans *xappTransaction) int {
 109         xapp.Logger.Info("handle_xapp_subs_resp")
 110         e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse()
 111         var e2SubsId int
 112
 113         //---------------------------------
 114         // xapp activity: Recv Subs Resp
 115         //---------------------------------
 116         select {
 117         case msg := <-xappConn.rmrConChan:
 118                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_RESP"] {
 119                         testError(t, "(%s) Received RIC_SUB_RESP wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_RESP", xapp.RicMessageTypeToName[msg.Mtype])
 120                         return -1
 121                 } else if msg.Xid != trans.xid {
 122                         testError(t, "(%s) Received RIC_SUB_RESP wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid)
 123                         return -1
 124                 } else {
 125                         packedData := &packer.PackedData{}
 126                         packedData.Buf = msg.Payload
 127                         e2SubsId = msg.SubId
 128                         unpackerr := e2SubsResp.UnPack(packedData)
 129
 130                         if unpackerr != nil {
 131                                 testError(t, "(%s) RIC_SUB_RESP unpack failed err: %s", xappConn.desc, unpackerr.Error())
 132                         }
 133                         geterr, resp := e2SubsResp.Get()
 134                         if geterr != nil {
 135                                 testError(t, "(%s) RIC_SUB_RESP get failed err: %s", xappConn.desc, geterr.Error())
 136                         }
 137
 138                         xapp.Logger.Info("(%s) Recv Subs Resp rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.desc, msg.Xid, msg.SubId, resp.RequestId.Seq)
 139                         return e2SubsId
 140                 }
 141         case <-time.After(15 * time.Second):
 142                 testError(t, "(%s) Not Received RIC_SUB_RESP within 15 secs", xappConn.desc)
 143                 return -1
 144         }
 145         return -1
 146 }
 147
 148 //-----------------------------------------------------------------------------
 149 //
 150 //-----------------------------------------------------------------------------
 151 func (xappConn *testingXappControl) handle_xapp_subs_del_req(t *testing.T, oldTrans *xappTransaction, e2SubsId int) *xappTransaction {
 152         xapp.Logger.Info("handle_xapp_subs_del_req")
 153         e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
 154
 155         //---------------------------------
 156         // xapp activity: Send Subs Del Req
 157         //---------------------------------
 158         xapp.Logger.Info("(%s) Send Subs Del Req", xappConn.desc)
 159
 160         req := &e2ap.E2APSubscriptionDeleteRequest{}
 161         req.RequestId.Id = 1
 162         req.RequestId.Seq = uint32(e2SubsId)
 163         req.FunctionId = 1
 164
 165         e2SubsDelReq.Set(req)
 166         xapp.Logger.Debug("%s", e2SubsDelReq.String())
 167         err, packedMsg := e2SubsDelReq.Pack(nil)
 168         if err != nil {
 169                 testError(t, "(%s) pack NOK %s", xappConn.desc, err.Error())
 170                 return nil
 171         }
 172
 173         var trans *xappTransaction = oldTrans
 174         if trans == nil {
 175                 trans = xappConn.newXappTransaction(nil, "RAN_NAME_1")
 176         }
 177
 178         params := &xapp.RMRParams{}
 179         params.Mtype = xapp.RIC_SUB_DEL_REQ
 180         params.SubId = e2SubsId
 181         params.Payload = packedMsg.Buf
 182         params.Meid = trans.meid
 183         params.Xid = trans.xid
 184         params.Mbuf = nil
 185
 186         snderr := xappConn.RmrSend(params)
 187         if snderr != nil {
 188                 testError(t, "(%s) RMR SEND FAILED: %s", xappConn.desc, snderr.Error())
 189                 return nil
 190         }
 191         return trans
 192 }
 193
 194 //-----------------------------------------------------------------------------
 195 //
 196 //-----------------------------------------------------------------------------
 197 func (xappConn *testingXappControl) handle_xapp_subs_del_resp(t *testing.T, trans *xappTransaction) {
 198         xapp.Logger.Info("handle_xapp_subs_del_resp")
 199         e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
 200
 201         //---------------------------------
 202         // xapp activity: Recv Subs Del Resp
 203         //---------------------------------
 204         select {
 205         case msg := <-xappConn.rmrConChan:
 206                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_RESP"] {
 207                         testError(t, "(%s) Received RIC_SUB_DEL_RESP wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_DEL_RESP", xapp.RicMessageTypeToName[msg.Mtype])
 208                         return
 209                 } else if msg.Xid != trans.xid {
 210                         testError(t, "(%s) Received RIC_SUB_DEL_RESP wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid)
 211                         return
 212                 } else {
 213                         packedData := &packer.PackedData{}
 214                         packedData.Buf = msg.Payload
 215                         unpackerr := e2SubsDelResp.UnPack(packedData)
 216                         if unpackerr != nil {
 217                                 testError(t, "(%s) RIC_SUB_DEL_RESP unpack failed err: %s", xappConn.desc, unpackerr.Error())
 218                         }
 219                         geterr, resp := e2SubsDelResp.Get()
 220                         if geterr != nil {
 221                                 testError(t, "(%s) RIC_SUB_DEL_RESP get failed err: %s", xappConn.desc, geterr.Error())
 222                         }
 223                         xapp.Logger.Info("(%s) Recv Subs Del Resp rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.desc, msg.Xid, msg.SubId, resp.RequestId.Seq)
 224                         return
 225                 }
 226         case <-time.After(15 * time.Second):
 227                 testError(t, "(%s) Not Received RIC_SUB_DEL_RESP within 15 secs", xappConn.desc)
 228         }
 229 }
 230
 231 //-----------------------------------------------------------------------------
 232 //
 233 //-----------------------------------------------------------------------------
 234 func (e2termConn *testingE2termControl) handle_e2term_subs_req(t *testing.T) (*e2ap.E2APSubscriptionRequest, *xapp.RMRParams) {
 235         xapp.Logger.Info("handle_e2term_subs_req")
 236         e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest()
 237
 238         //---------------------------------
 239         // e2term activity: Recv Subs Req
 240         //---------------------------------
 241         select {
 242         case msg := <-e2termConn.rmrConChan:
 243                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_REQ"] {
 244                         testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.desc, "RIC_SUB_REQ", xapp.RicMessageTypeToName[msg.Mtype])
 245                 } else {
 246                         xapp.Logger.Info("(%s) Recv Subs Req", e2termConn.desc)
 247                         packedData := &packer.PackedData{}
 248                         packedData.Buf = msg.Payload
 249                         unpackerr := e2SubsReq.UnPack(packedData)
 250                         if unpackerr != nil {
 251                                 testError(t, "(%s) RIC_SUB_REQ unpack failed err: %s", e2termConn.desc, unpackerr.Error())
 252                         }
 253                         geterr, req := e2SubsReq.Get()
 254                         if geterr != nil {
 255                                 testError(t, "(%s) RIC_SUB_REQ get failed err: %s", e2termConn.desc, geterr.Error())
 256                         }
 257                         return req, msg
 258                 }
 259         case <-time.After(15 * time.Second):
 260                 testError(t, "(%s) Not Received RIC_SUB_REQ within 15 secs", e2termConn.desc)
 261         }
 262         return nil, nil
 263 }
 264
 265 func (e2termConn *testingE2termControl) handle_e2term_subs_resp(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *xapp.RMRParams) {
 266         xapp.Logger.Info("handle_e2term_subs_resp")
 267         e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse()
 268
 269         //---------------------------------
 270         // e2term activity: Send Subs Resp
 271         //---------------------------------
 272         xapp.Logger.Info("(%s) Send Subs Resp", e2termConn.desc)
 273
 274         resp := &e2ap.E2APSubscriptionResponse{}
 275
 276         resp.RequestId.Id = req.RequestId.Id
 277         resp.RequestId.Seq = req.RequestId.Seq
 278         resp.FunctionId = req.FunctionId
 279
 280         resp.ActionAdmittedList.Items = make([]e2ap.ActionAdmittedItem, len(req.ActionSetups))
 281         for index := int(0); index < len(req.ActionSetups); index++ {
 282                 resp.ActionAdmittedList.Items[index].ActionId = req.ActionSetups[index].ActionId
 283         }
 284
 285         for index := uint64(0); index < 1; index++ {
 286                 item := e2ap.ActionNotAdmittedItem{}
 287                 item.ActionId = index
 288                 item.Cause.Content = 1
 289                 item.Cause.CauseVal = 1
 290                 resp.ActionNotAdmittedList.Items = append(resp.ActionNotAdmittedList.Items, item)
 291         }
 292
 293         e2SubsResp.Set(resp)
 294         xapp.Logger.Debug("%s", e2SubsResp.String())
 295         packerr, packedMsg := e2SubsResp.Pack(nil)
 296         if packerr != nil {
 297                 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
 298         }
 299
 300         params := &xapp.RMRParams{}
 301         params.Mtype = xapp.RIC_SUB_RESP
 302         params.SubId = msg.SubId
 303         params.Payload = packedMsg.Buf
 304         params.Meid = msg.Meid
 305         params.Xid = msg.Xid
 306         params.Mbuf = nil
 307
 308         snderr := e2termConn.RmrSend(params)
 309         if snderr != nil {
 310                 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
 311         }
 312 }
 313
 314 //-----------------------------------------------------------------------------
 315 //
 316 //-----------------------------------------------------------------------------
 317 func (e2termConn *testingE2termControl) handle_e2term_subs_del_req(t *testing.T) (*e2ap.E2APSubscriptionDeleteRequest, *xapp.RMRParams) {
 318         xapp.Logger.Info("handle_e2term_subs_del_req")
 319         e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
 320
 321         //---------------------------------
 322         // e2term activity: Recv Subs Del Req
 323         //---------------------------------
 324         select {
 325         case msg := <-e2termConn.rmrConChan:
 326                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_REQ"] {
 327                         testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.desc, "RIC_SUB_DEL_REQ", xapp.RicMessageTypeToName[msg.Mtype])
 328                 } else {
 329                         xapp.Logger.Info("(%s) Recv Subs Del Req", e2termConn.desc)
 330
 331                         packedData := &packer.PackedData{}
 332                         packedData.Buf = msg.Payload
 333                         unpackerr := e2SubsDelReq.UnPack(packedData)
 334                         if unpackerr != nil {
 335                                 testError(t, "(%s) RIC_SUB_DEL_REQ unpack failed err: %s", e2termConn.desc, unpackerr.Error())
 336                         }
 337                         geterr, req := e2SubsDelReq.Get()
 338                         if geterr != nil {
 339                                 testError(t, "(%s) RIC_SUB_DEL_REQ get failed err: %s", e2termConn.desc, geterr.Error())
 340                         }
 341                         return req, msg
 342                 }
 343         case <-time.After(15 * time.Second):
 344                 testError(t, "(%s) Not Received RIC_SUB_DEL_REQ within 15 secs", e2termConn.desc)
 345         }
 346         return nil, nil
 347 }
 348
 349 func handle_e2term_recv_empty() bool {
 350         if len(e2termConn.rmrConChan) > 0 {
 351                 return false
 352         }
 353         return true
 354 }
 355
 356 func (e2termConn *testingE2termControl) handle_e2term_subs_del_resp(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *xapp.RMRParams) {
 357         xapp.Logger.Info("handle_e2term_subs_del_resp")
 358         e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
 359
 360         //---------------------------------
 361         // e2term activity: Send Subs Del Resp
 362         //---------------------------------
 363         xapp.Logger.Info("(%s) Send Subs Del Resp", e2termConn.desc)
 364
 365         resp := &e2ap.E2APSubscriptionDeleteResponse{}
 366         resp.RequestId.Id = req.RequestId.Id
 367         resp.RequestId.Seq = req.RequestId.Seq
 368         resp.FunctionId = req.FunctionId
 369
 370         e2SubsDelResp.Set(resp)
 371         xapp.Logger.Debug("%s", e2SubsDelResp.String())
 372         packerr, packedMsg := e2SubsDelResp.Pack(nil)
 373         if packerr != nil {
 374                 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
 375         }
 376
 377         params := &xapp.RMRParams{}
 378         params.Mtype = xapp.RIC_SUB_DEL_RESP
 379         params.SubId = msg.SubId
 380         params.Payload = packedMsg.Buf
 381         params.Meid = msg.Meid
 382         params.Xid = msg.Xid
 383         params.Mbuf = nil
 384
 385         snderr := e2termConn.RmrSend(params)
 386         if snderr != nil {
 387                 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
 388         }
 389
 390 }
 391
 392 //-----------------------------------------------------------------------------
 393 //
 394 //-----------------------------------------------------------------------------
 395 func (mc *testingMainControl) wait_subs_clean(t *testing.T, e2SubsId int, secs int) bool {
 396         i := 1
 397         for ; i <= secs*2; i++ {
 398                 if mc.c.registry.IsValidSequenceNumber(uint16(e2SubsId)) == false {
 399                         return true
 400                 }
 401                 time.Sleep(500 * time.Millisecond)
 402         }
 403         testError(t, "(general) no clean within %d secs", secs)
 404         return false
 405 }
 406
 407 func (mc *testingMainControl) get_seqcnt(t *testing.T) uint16 {
 408         mc.c.registry.mutex.Lock()
 409         defer mc.c.registry.mutex.Unlock()
 410         return mc.c.registry.counter
 411 }
 412
 413 func (mc *testingMainControl) wait_seqcnt_change(t *testing.T, orig uint16, secs int) (uint16, bool) {
 414         i := 1
 415         for ; i <= secs*2; i++ {
 416                 mc.c.registry.mutex.Lock()
 417                 curr := mc.c.registry.counter
 418                 mc.c.registry.mutex.Unlock()
 419                 if curr != orig {
 420                         return curr, true
 421                 }
 422                 time.Sleep(500 * time.Millisecond)
 423         }
 424         testError(t, "(general) no seq change within %d secs", secs)
 425         return 0, false
 426 }
 427
 428 func (mc *testingMainControl) get_msgcounter(t *testing.T) uint64 {
 429         return mc.c.msgCounter
 430 }
 431
 432 func (mc *testingMainControl) wait_msgcounter_change(t *testing.T, orig uint64, secs int) (uint64, bool) {
 433         i := 1
 434         for ; i <= secs*2; i++ {
 435                 curr := mc.c.msgCounter
 436                 if curr != orig {
 437                         return curr, true
 438                 }
 439                 time.Sleep(500 * time.Millisecond)
 440         }
 441         testError(t, "(general) no msg counter change within %d secs", secs)
 442         return 0, false
 443 }
 444
 445 //-----------------------------------------------------------------------------
 446 // TestSubReqAndSubDelOk
 447 //
 448 //   stub                          stub
 449 // +-------+     +---------+    +---------+
 450 // | xapp  |     | submgr  |    | e2term  |
 451 // +-------+     +---------+    +---------+
 452 //     |              |              |
 453 //     | SubReq       |              |
 454 //     |------------->|              |
 455 //     |              |              |
 456 //     |              | SubReq       |
 457 //     |              |------------->|
 458 //     |              |              |
 459 //     |              |      SubResp |
 460 //     |              |<-------------|
 461 //     |              |              |
 462 //     |      SubResp |              |
 463 //     |<-------------|              |
 464 //     |              |              |
 465 //     |              |              |
 466 //     | SubDelReq    |              |
 467 //     |------------->|              |
 468 //     |              |              |
 469 //     |              | SubDelReq    |
 470 //     |              |------------->|
 471 //     |              |              |
 472 //     |              |   SubDelResp |
 473 //     |              |<-------------|
 474 //     |              |              |
 475 //     |   SubDelResp |              |
 476 //     |<-------------|              |
 477 //
 478 //-----------------------------------------------------------------------------
 479 func TestSubReqAndSubDelOk(t *testing.T) {
 480         xapp.Logger.Info("TestSubReqAndSubDelOk")
 481
 482         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 483         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 484         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 485         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 486
 487         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 488         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 489         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 490         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 491
 492         //Wait that subs is cleaned
 493         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 494 }
 495
 496 //-----------------------------------------------------------------------------
 497 // TestSubReqRetransmission
 498 //
 499 //   stub                          stub
 500 // +-------+     +---------+    +---------+
 501 // | xapp  |     | submgr  |    | e2term  |
 502 // +-------+     +---------+    +---------+
 503 //     |              |              |
 504 //     |  SubReq      |              |
 505 //     |------------->|              |
 506 //     |              |              |
 507 //     |              | SubReq       |
 508 //     |              |------------->|
 509 //     |              |              |
 510 //     |  SubReq      |              |
 511 //     | (retrans)    |              |
 512 //     |------------->|              |
 513 //     |              |              |
 514 //     |              |      SubResp |
 515 //     |              |<-------------|
 516 //     |              |              |
 517 //     |      SubResp |              |
 518 //     |<-------------|              |
 519 //     |              |              |
 520 //     |         [SUBS DELETE]       |
 521 //     |              |              |
 522 //
 523 //-----------------------------------------------------------------------------
 524 func TestSubReqRetransmission(t *testing.T) {
 525         xapp.Logger.Info("TestSubReqRetransmission")
 526
 527         //Subs Create
 528         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 529         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 530
 531         seqBef := mainCtrl.get_msgcounter(t)
 532         xappConn1.handle_xapp_subs_req(t, cretrans) //Retransmitted SubReq
 533         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 534
 535         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 536         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 537
 538         //Subs Delete
 539         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 540         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 541         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 542         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 543
 544         //Wait that subs is cleaned
 545         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 546 }
 547
 548 //-----------------------------------------------------------------------------
 549 // TestSubDelReqRetransmission
 550 //
 551 //   stub                          stub
 552 // +-------+     +---------+    +---------+
 553 // | xapp  |     | submgr  |    | e2term  |
 554 // +-------+     +---------+    +---------+
 555 //     |              |              |
 556 //     |         [SUBS CREATE]       |
 557 //     |              |              |
 558 //     |              |              |
 559 //     | SubDelReq    |              |
 560 //     |------------->|              |
 561 //     |              |              |
 562 //     |              | SubDelReq    |
 563 //     |              |------------->|
 564 //     |              |              |
 565 //     | SubDelReq    |              |
 566 //     |------------->|              |
 567 //     |              |              |
 568 //     |              |   SubDelResp |
 569 //     |              |<-------------|
 570 //     |              |              |
 571 //     |   SubDelResp |              |
 572 //     |<-------------|              |
 573 //
 574 //-----------------------------------------------------------------------------
 575 func TestSubDelReqRetransmission(t *testing.T) {
 576         xapp.Logger.Info("TestSubDelReqRetransmission")
 577
 578         //Subs Create
 579         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 580         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 581         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 582         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 583
 584         //Subs Delete
 585         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 586         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 587
 588         seqBef := mainCtrl.get_msgcounter(t)
 589         xappConn1.handle_xapp_subs_del_req(t, deltrans, e2SubsId) //Retransmitted SubDelReq
 590         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 591
 592         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 593         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 594
 595         //Wait that subs is cleaned
 596         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 597 }
 598
 599 //-----------------------------------------------------------------------------
 600 // TestSubReqAndSubDelOkTwoParallel
 601 //
 602 //   stub                          stub
 603 // +-------+     +---------+    +---------+
 604 // | xapp  |     | submgr  |    | e2term  |
 605 // +-------+     +---------+    +---------+
 606 //     |              |              |
 607 //     |              |              |
 608 //     |              |              |
 609 //     | SubReq1      |              |
 610 //     |------------->|              |
 611 //     |              |              |
 612 //     |              | SubReq1      |
 613 //     |              |------------->|
 614 //     |              |              |
 615 //     | SubReq2      |              |
 616 //     |------------->|              |
 617 //     |              |              |
 618 //     |              | SubReq2      |
 619 //     |              |------------->|
 620 //     |              |              |
 621 //     |              |    SubResp1  |
 622 //     |              |<-------------|
 623 //     |              |    SubResp2  |
 624 //     |              |<-------------|
 625 //     |              |              |
 626 //     |    SubResp1  |              |
 627 //     |<-------------|              |
 628 //     |    SubResp2  |              |
 629 //     |<-------------|              |
 630 //     |              |              |
 631 //     |        [SUBS 1 DELETE]      |
 632 //     |              |              |
 633 //     |        [SUBS 2 DELETE]      |
 634 //     |              |              |
 635 //
 636 //-----------------------------------------------------------------------------
 637 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
 638         xapp.Logger.Info("TestSubReqAndSubDelOkTwoParallel")
 639
 640         //Req1
 641         cretrans1 := xappConn1.handle_xapp_subs_req(t, nil)
 642         crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t)
 643
 644         //Req2
 645         cretrans2 := xappConn2.handle_xapp_subs_req(t, nil)
 646         crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t)
 647
 648         //Resp1
 649         e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1)
 650         e2SubsId1 := xappConn1.handle_xapp_subs_resp(t, cretrans1)
 651
 652         //Resp2
 653         e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2)
 654         e2SubsId2 := xappConn2.handle_xapp_subs_resp(t, cretrans2)
 655
 656         //Del1
 657         deltrans1 := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId1)
 658         delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t)
 659         e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1)
 660         xappConn1.handle_xapp_subs_del_resp(t, deltrans1)
 661         //Wait that subs is cleaned
 662         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
 663
 664         //Del2
 665         deltrans2 := xappConn2.handle_xapp_subs_del_req(t, nil, e2SubsId2)
 666         delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t)
 667         e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2)
 668         xappConn2.handle_xapp_subs_del_resp(t, deltrans2)
 669         //Wait that subs is cleaned
 670         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
 671 }
 672
 673 //-----------------------------------------------------------------------------
 674 // TestSameSubsDiffRan
 675 // Same subscription to different RANs
 676 //
 677 //   stub                          stub
 678 // +-------+     +---------+    +---------+
 679 // | xapp  |     | submgr  |    | e2term  |
 680 // +-------+     +---------+    +---------+
 681 //     |              |              |
 682 //     |              |              |
 683 //     |              |              |
 684 //     | SubReq(r1)   |              |
 685 //     |------------->|              |
 686 //     |              |              |
 687 //     |              | SubReq(r1)   |
 688 //     |              |------------->|
 689 //     |              |              |
 690 //     |              | SubResp(r1)  |
 691 //     |              |<-------------|
 692 //     |              |              |
 693 //     | SubResp(r1)  |              |
 694 //     |<-------------|              |
 695 //     |              |              |
 696 //     | SubReq(r2)   |              |
 697 //     |------------->|              |
 698 //     |              |              |
 699 //     |              | SubReq(r2)   |
 700 //     |              |------------->|
 701 //     |              |              |
 702 //     |              | SubResp(r2)  |
 703 //     |              |<-------------|
 704 //     |              |              |
 705 //     | SubResp(r2)  |              |
 706 //     |<-------------|              |
 707 //     |              |              |
 708 //     |       [SUBS r1 DELETE]      |
 709 //     |              |              |
 710 //     |       [SUBS r2 DELETE]      |
 711 //     |              |              |
 712 //
 713 //-----------------------------------------------------------------------------
 714 func TestSameSubsDiffRan(t *testing.T) {
 715         xapp.Logger.Info("TestSameSubsDiffRan")
 716
 717         //Req1
 718         cretrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
 719         xappConn1.handle_xapp_subs_req(t, cretrans1)
 720         crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t)
 721         e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1)
 722         e2SubsId1 := xappConn1.handle_xapp_subs_resp(t, cretrans1)
 723
 724         //Req2
 725         cretrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2")
 726         xappConn1.handle_xapp_subs_req(t, cretrans2)
 727         crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t)
 728         e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2)
 729         e2SubsId2 := xappConn1.handle_xapp_subs_resp(t, cretrans2)
 730
 731         //Del1
 732         deltrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
 733         xappConn1.handle_xapp_subs_del_req(t, deltrans1, e2SubsId1)
 734         delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t)
 735         e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1)
 736         xappConn1.handle_xapp_subs_del_resp(t, deltrans1)
 737         //Wait that subs is cleaned
 738         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
 739
 740         //Del2
 741         deltrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2")
 742         xappConn1.handle_xapp_subs_del_req(t, deltrans2, e2SubsId2)
 743         delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t)
 744         e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2)
 745         xappConn1.handle_xapp_subs_del_resp(t, deltrans2)
 746         //Wait that subs is cleaned
 747         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
 748 }