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.GetSubscription(uint16(e2SubsId)) == nil {
 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) wait_subs_trans_clean(t *testing.T, e2SubsId int, secs int) bool {
 408         i := 1
 409         for ; i <= secs*2; i++ {
 410                 subs := mc.c.registry.GetSubscription(uint16(e2SubsId))
 411                 if subs == nil {
 412                         return true
 413                 }
 414                 trans := subs.GetTransaction()
 415                 if trans == nil {
 416                         return true
 417                 }
 418                 time.Sleep(500 * time.Millisecond)
 419         }
 420         testError(t, "(general) no clean within %d secs", secs)
 421         return false
 422 }
 423
 424 func (mc *testingMainControl) get_seqcnt(t *testing.T) uint16 {
 425         mc.c.registry.mutex.Lock()
 426         defer mc.c.registry.mutex.Unlock()
 427         return mc.c.registry.counter
 428 }
 429
 430 func (mc *testingMainControl) wait_seqcnt_change(t *testing.T, orig uint16, secs int) (uint16, bool) {
 431         i := 1
 432         for ; i <= secs*2; i++ {
 433                 mc.c.registry.mutex.Lock()
 434                 curr := mc.c.registry.counter
 435                 mc.c.registry.mutex.Unlock()
 436                 if curr != orig {
 437                         return curr, true
 438                 }
 439                 time.Sleep(500 * time.Millisecond)
 440         }
 441         testError(t, "(general) no seq change within %d secs", secs)
 442         return 0, false
 443 }
 444
 445 func (mc *testingMainControl) get_msgcounter(t *testing.T) uint64 {
 446         return mc.c.msgCounter
 447 }
 448
 449 func (mc *testingMainControl) wait_msgcounter_change(t *testing.T, orig uint64, secs int) (uint64, bool) {
 450         i := 1
 451         for ; i <= secs*2; i++ {
 452                 curr := mc.c.msgCounter
 453                 if curr != orig {
 454                         return curr, true
 455                 }
 456                 time.Sleep(500 * time.Millisecond)
 457         }
 458         testError(t, "(general) no msg counter change within %d secs", secs)
 459         return 0, false
 460 }
 461
 462 //-----------------------------------------------------------------------------
 463 // TestSubReqAndSubDelOk
 464 //
 465 //   stub                          stub
 466 // +-------+     +---------+    +---------+
 467 // | xapp  |     | submgr  |    | e2term  |
 468 // +-------+     +---------+    +---------+
 469 //     |              |              |
 470 //     | SubReq       |              |
 471 //     |------------->|              |
 472 //     |              |              |
 473 //     |              | SubReq       |
 474 //     |              |------------->|
 475 //     |              |              |
 476 //     |              |      SubResp |
 477 //     |              |<-------------|
 478 //     |              |              |
 479 //     |      SubResp |              |
 480 //     |<-------------|              |
 481 //     |              |              |
 482 //     |              |              |
 483 //     | SubDelReq    |              |
 484 //     |------------->|              |
 485 //     |              |              |
 486 //     |              | SubDelReq    |
 487 //     |              |------------->|
 488 //     |              |              |
 489 //     |              |   SubDelResp |
 490 //     |              |<-------------|
 491 //     |              |              |
 492 //     |   SubDelResp |              |
 493 //     |<-------------|              |
 494 //
 495 //-----------------------------------------------------------------------------
 496 func TestSubReqAndSubDelOk(t *testing.T) {
 497         xapp.Logger.Info("TestSubReqAndSubDelOk")
 498
 499         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 500         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 501         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 502         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 503
 504         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 505         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 506         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 507         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 508
 509         //Wait that subs is cleaned
 510         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 511 }
 512
 513 //-----------------------------------------------------------------------------
 514 // TestSubReqRetransmission
 515 //
 516 //   stub                          stub
 517 // +-------+     +---------+    +---------+
 518 // | xapp  |     | submgr  |    | e2term  |
 519 // +-------+     +---------+    +---------+
 520 //     |              |              |
 521 //     |  SubReq      |              |
 522 //     |------------->|              |
 523 //     |              |              |
 524 //     |              | SubReq       |
 525 //     |              |------------->|
 526 //     |              |              |
 527 //     |  SubReq      |              |
 528 //     | (retrans)    |              |
 529 //     |------------->|              |
 530 //     |              |              |
 531 //     |              |      SubResp |
 532 //     |              |<-------------|
 533 //     |              |              |
 534 //     |      SubResp |              |
 535 //     |<-------------|              |
 536 //     |              |              |
 537 //     |         [SUBS DELETE]       |
 538 //     |              |              |
 539 //
 540 //-----------------------------------------------------------------------------
 541 func TestSubReqRetransmission(t *testing.T) {
 542         xapp.Logger.Info("TestSubReqRetransmission")
 543
 544         //Subs Create
 545         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 546         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 547
 548         seqBef := mainCtrl.get_msgcounter(t)
 549         xappConn1.handle_xapp_subs_req(t, cretrans) //Retransmitted SubReq
 550         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 551
 552         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 553         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 554
 555         //Subs Delete
 556         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 557         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 558         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 559         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 560
 561         //Wait that subs is cleaned
 562         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 563 }
 564
 565 //-----------------------------------------------------------------------------
 566 // TestSubDelReqRetransmission
 567 //
 568 //   stub                          stub
 569 // +-------+     +---------+    +---------+
 570 // | xapp  |     | submgr  |    | e2term  |
 571 // +-------+     +---------+    +---------+
 572 //     |              |              |
 573 //     |         [SUBS CREATE]       |
 574 //     |              |              |
 575 //     |              |              |
 576 //     | SubDelReq    |              |
 577 //     |------------->|              |
 578 //     |              |              |
 579 //     |              | SubDelReq    |
 580 //     |              |------------->|
 581 //     |              |              |
 582 //     | SubDelReq    |              |
 583 //     | (same sub)   |              |
 584 //     | (same xid)   |              |
 585 //     |------------->|              |
 586 //     |              |              |
 587 //     |              |   SubDelResp |
 588 //     |              |<-------------|
 589 //     |              |              |
 590 //     |   SubDelResp |              |
 591 //     |<-------------|              |
 592 //
 593 //-----------------------------------------------------------------------------
 594 func TestSubDelReqRetransmission(t *testing.T) {
 595         xapp.Logger.Info("TestSubDelReqRetransmission")
 596
 597         //Subs Create
 598         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 599         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 600         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 601         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 602
 603         //Subs Delete
 604         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 605         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 606
 607         seqBef := mainCtrl.get_msgcounter(t)
 608         xappConn1.handle_xapp_subs_del_req(t, deltrans, e2SubsId) //Retransmitted SubDelReq
 609         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 610
 611         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 612         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 613
 614         //Wait that subs is cleaned
 615         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 616 }
 617
 618 //-----------------------------------------------------------------------------
 619 // TestSubDelReqCollision
 620 //
 621 //   stub                          stub
 622 // +-------+     +---------+    +---------+
 623 // | xapp  |     | submgr  |    | e2term  |
 624 // +-------+     +---------+    +---------+
 625 //     |              |              |
 626 //     |         [SUBS CREATE]       |
 627 //     |              |              |
 628 //     |              |              |
 629 //     | SubDelReq    |              |
 630 //     |------------->|              |
 631 //     |              |              |
 632 //     |              | SubDelReq    |
 633 //     |              |------------->|
 634 //     |              |              |
 635 //     | SubDelReq    |              |
 636 //     | (same sub)   |              |
 637 //     | (diff xid)   |              |
 638 //     |------------->|              |
 639 //     |              |              |
 640 //     |              |   SubDelResp |
 641 //     |              |<-------------|
 642 //     |              |              |
 643 //     |   SubDelResp |              |
 644 //     |<-------------|              |
 645 //
 646 //-----------------------------------------------------------------------------
 647 func TestSubDelReqCollision(t *testing.T) {
 648         xapp.Logger.Info("TestSubDelReqCollision")
 649
 650         //Subs Create
 651         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 652         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 653         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 654         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 655
 656         //Subs Delete
 657         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 658         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 659
 660         seqBef := mainCtrl.get_msgcounter(t)
 661         deltranscol := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
 662         xappConn1.handle_xapp_subs_del_req(t, deltranscol, e2SubsId) //Colliding SubDelReq
 663         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 664
 665         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 666         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 667
 668         //Wait that subs is cleaned
 669         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 670 }
 671
 672 //-----------------------------------------------------------------------------
 673 // TestSubReqAndSubDelOkTwoParallel
 674 //
 675 //   stub                          stub
 676 // +-------+     +---------+    +---------+
 677 // | xapp  |     | submgr  |    | e2term  |
 678 // +-------+     +---------+    +---------+
 679 //     |              |              |
 680 //     |              |              |
 681 //     |              |              |
 682 //     | SubReq1      |              |
 683 //     |------------->|              |
 684 //     |              |              |
 685 //     |              | SubReq1      |
 686 //     |              |------------->|
 687 //     |              |              |
 688 //     | SubReq2      |              |
 689 //     |------------->|              |
 690 //     |              |              |
 691 //     |              | SubReq2      |
 692 //     |              |------------->|
 693 //     |              |              |
 694 //     |              |    SubResp1  |
 695 //     |              |<-------------|
 696 //     |              |    SubResp2  |
 697 //     |              |<-------------|
 698 //     |              |              |
 699 //     |    SubResp1  |              |
 700 //     |<-------------|              |
 701 //     |    SubResp2  |              |
 702 //     |<-------------|              |
 703 //     |              |              |
 704 //     |        [SUBS 1 DELETE]      |
 705 //     |              |              |
 706 //     |        [SUBS 2 DELETE]      |
 707 //     |              |              |
 708 //
 709 //-----------------------------------------------------------------------------
 710 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
 711         xapp.Logger.Info("TestSubReqAndSubDelOkTwoParallel")
 712
 713         //Req1
 714         cretrans1 := xappConn1.handle_xapp_subs_req(t, nil)
 715         crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t)
 716
 717         //Req2
 718         cretrans2 := xappConn2.handle_xapp_subs_req(t, nil)
 719         crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t)
 720
 721         //Resp1
 722         e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1)
 723         e2SubsId1 := xappConn1.handle_xapp_subs_resp(t, cretrans1)
 724
 725         //Resp2
 726         e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2)
 727         e2SubsId2 := xappConn2.handle_xapp_subs_resp(t, cretrans2)
 728
 729         //Del1
 730         deltrans1 := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId1)
 731         delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t)
 732         e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1)
 733         xappConn1.handle_xapp_subs_del_resp(t, deltrans1)
 734         //Wait that subs is cleaned
 735         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
 736
 737         //Del2
 738         deltrans2 := xappConn2.handle_xapp_subs_del_req(t, nil, e2SubsId2)
 739         delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t)
 740         e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2)
 741         xappConn2.handle_xapp_subs_del_resp(t, deltrans2)
 742         //Wait that subs is cleaned
 743         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
 744 }
 745
 746 //-----------------------------------------------------------------------------
 747 // TestSameSubsDiffRan
 748 // Same subscription to different RANs
 749 //
 750 //   stub                          stub
 751 // +-------+     +---------+    +---------+
 752 // | xapp  |     | submgr  |    | e2term  |
 753 // +-------+     +---------+    +---------+
 754 //     |              |              |
 755 //     |              |              |
 756 //     |              |              |
 757 //     | SubReq(r1)   |              |
 758 //     |------------->|              |
 759 //     |              |              |
 760 //     |              | SubReq(r1)   |
 761 //     |              |------------->|
 762 //     |              |              |
 763 //     |              | SubResp(r1)  |
 764 //     |              |<-------------|
 765 //     |              |              |
 766 //     | SubResp(r1)  |              |
 767 //     |<-------------|              |
 768 //     |              |              |
 769 //     | SubReq(r2)   |              |
 770 //     |------------->|              |
 771 //     |              |              |
 772 //     |              | SubReq(r2)   |
 773 //     |              |------------->|
 774 //     |              |              |
 775 //     |              | SubResp(r2)  |
 776 //     |              |<-------------|
 777 //     |              |              |
 778 //     | SubResp(r2)  |              |
 779 //     |<-------------|              |
 780 //     |              |              |
 781 //     |       [SUBS r1 DELETE]      |
 782 //     |              |              |
 783 //     |       [SUBS r2 DELETE]      |
 784 //     |              |              |
 785 //
 786 //-----------------------------------------------------------------------------
 787 func TestSameSubsDiffRan(t *testing.T) {
 788         xapp.Logger.Info("TestSameSubsDiffRan")
 789
 790         //Req1
 791         cretrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
 792         xappConn1.handle_xapp_subs_req(t, cretrans1)
 793         crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t)
 794         e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1)
 795         e2SubsId1 := xappConn1.handle_xapp_subs_resp(t, cretrans1)
 796
 797         //Req2
 798         cretrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2")
 799         xappConn1.handle_xapp_subs_req(t, cretrans2)
 800         crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t)
 801         e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2)
 802         e2SubsId2 := xappConn1.handle_xapp_subs_resp(t, cretrans2)
 803
 804         //Del1
 805         deltrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
 806         xappConn1.handle_xapp_subs_del_req(t, deltrans1, e2SubsId1)
 807         delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t)
 808         e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1)
 809         xappConn1.handle_xapp_subs_del_resp(t, deltrans1)
 810         //Wait that subs is cleaned
 811         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
 812
 813         //Del2
 814         deltrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2")
 815         xappConn1.handle_xapp_subs_del_req(t, deltrans2, e2SubsId2)
 816         delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t)
 817         e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2)
 818         xappConn1.handle_xapp_subs_del_resp(t, deltrans2)
 819         //Wait that subs is cleaned
 820         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
 821 }
 822
 823 //-----------------------------------------------------------------------------
 824 // TestSubReqRetryInSubmgr
 825 //
 826 //   stub                          stub
 827 // +-------+     +---------+    +---------+
 828 // | xapp  |     | submgr  |    | e2term  |
 829 // +-------+     +---------+    +---------+
 830 //     |              |              |
 831 //     |  SubReq      |              |
 832 //     |------------->|              |
 833 //     |              |              |
 834 //     |              | SubReq       |
 835 //     |              |------------->|
 836 //     |              |              |
 837 //     |              |              |
 838 //     |              | SubReq       |
 839 //     |              |------------->|
 840 //     |              |              |
 841 //     |              |      SubResp |
 842 //     |              |<-------------|
 843 //     |              |              |
 844 //     |      SubResp |              |
 845 //     |<-------------|              |
 846 //     |              |              |
 847 //     |         [SUBS DELETE]       |
 848 //     |              |              |
 849 //
 850 //-----------------------------------------------------------------------------
 851
 852 func TestSubReqRetryInSubmgr(t *testing.T) {
 853
 854         xapp.Logger.Info("TestSubReqRetryInSubmgr start")
 855
 856         // Xapp: Send SubsReq
 857         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 858
 859         // E2t: Receive 1st SubsReq
 860         e2termConn.handle_e2term_subs_req(t)
 861
 862         // E2t: Receive 2nd SubsReq and send SubsResp
 863         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 864         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 865
 866         // Xapp: Receive SubsResp
 867         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 868
 869         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 870         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 871         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 872         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 873
 874         // Wait that subs is cleaned
 875         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 876 }
 877
 878 //-----------------------------------------------------------------------------
 879 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
 880 //
 881 //   stub                          stub
 882 // +-------+     +---------+    +---------+
 883 // | xapp  |     | submgr  |    | e2term  |
 884 // +-------+     +---------+    +---------+
 885 //     |              |              |
 886 //     |  SubReq      |              |
 887 //     |------------->|              |
 888 //     |              |              |
 889 //     |              | SubReq       |
 890 //     |              |------------->|
 891 //     |              |              |
 892 //     |              |              |
 893 //     |              | SubReq       |
 894 //     |              |------------->|
 895 //     |              |              |
 896 //     |              | SubDelReq    |
 897 //     |              |------------->|
 898 //     |              |              |
 899 //     |              |              |
 900 //     |              | SubDelReq    |
 901 //     |              |------------->|
 902 //     |              |              |
 903 //     |              |              |
 904 //     |              |   SubDelResp |
 905 //     |              |<-------------|
 906 //     |              |              |
 907 //
 908 //-----------------------------------------------------------------------------
 909
 910 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
 911
 912         xapp.Logger.Info("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
 913
 914         // Xapp: Send SubsReq
 915         xappConn1.handle_xapp_subs_req(t, nil)
 916
 917         // E2t: Receive 1st SubsReq
 918         e2termConn.handle_e2term_subs_req(t)
 919
 920         // E2t: Receive 2nd SubsReq
 921         e2termConn.handle_e2term_subs_req(t)
 922
 923         // E2t: Send receive SubsReq and send SubsResp
 924         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 925         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 926
 927         // Wait that subs is cleaned
 928         mainCtrl.wait_subs_clean(t, int(delreq.RequestId.Seq), 10)
 929 }
 930
 931 //-----------------------------------------------------------------------------
 932 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
 933 //
 934 //   stub                          stub
 935 // +-------+     +---------+    +---------+
 936 // | xapp  |     | submgr  |    | e2term  |
 937 // +-------+     +---------+    +---------+
 938 //     |              |              |
 939 //     |  SubReq      |              |
 940 //     |------------->|              |
 941 //     |              |              |
 942 //     |              | SubReq       |
 943 //     |              |------------->|
 944 //     |              |              |
 945 //     |              |              |
 946 //     |              | SubReq       |
 947 //     |              |------------->|
 948 //     |              |              |
 949 //     |              | SubDelReq    |
 950 //     |              |------------->|
 951 //     |              |              |
 952 //     |              |              |
 953 //     |              | SubDelReq    |
 954 //     |              |------------->|
 955 //     |              |              |
 956 //     |              |              |
 957 //
 958 //-----------------------------------------------------------------------------
 959
 960 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
 961
 962         xapp.Logger.Info("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
 963
 964         // Xapp: Send SubsReq
 965         xappConn1.handle_xapp_subs_req(t, nil)
 966
 967         // E2t: Receive 1st SubsReq
 968         e2termConn.handle_e2term_subs_req(t)
 969
 970         // E2t: Receive 2nd SubsReq
 971         e2termConn.handle_e2term_subs_req(t)
 972
 973         // E2t: Receive 1st SubsDelReq
 974         e2termConn.handle_e2term_subs_del_req(t)
 975
 976         // E2t: Receive 2nd SubsDelReq
 977         delreq, _ := e2termConn.handle_e2term_subs_del_req(t)
 978
 979         // Wait that subs is cleaned
 980         mainCtrl.wait_subs_clean(t, int(delreq.RequestId.Seq), 10)
 981 }
 982
 983 //-----------------------------------------------------------------------------
 984 // TestSubDelReqRetryInSubmgr
 985 //
 986 //   stub                          stub
 987 // +-------+     +---------+    +---------+
 988 // | xapp  |     | submgr  |    | e2term  |
 989 // +-------+     +---------+    +---------+
 990 //     |              |              |
 991 //     |         [SUBS CREATE]       |
 992 //     |              |              |
 993 //     |              |              |
 994 //     | SubDelReq    |              |
 995 //     |------------->|              |
 996 //     |              |              |
 997 //     |              | SubDelReq    |
 998 //     |              |------------->|
 999 //     |              |              |
1000 //     |              | SubDelReq    |
1001 //     |              |------------->|
1002 //     |              |              |
1003 //     |              |   SubDelResp |
1004 //     |              |<-------------|
1005 //     |              |              |
1006 //     |   SubDelResp |              |
1007 //     |<-------------|              |
1008 //
1009 //-----------------------------------------------------------------------------
1010
1011 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1012
1013         xapp.Logger.Info("TestSubDelReqRetryInSubmgr start")
1014
1015         // Subs Create
1016         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1017         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1018         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1019         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1020
1021         // Subs Delete
1022         // Xapp: Send SubsDelReq
1023         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1024
1025         // E2t: Receive 1st SubsDelReq
1026         e2termConn.handle_e2term_subs_del_req(t)
1027
1028         // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1029         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1030         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
1031
1032         // Xapp: Receive SubsDelReq
1033         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1034
1035         // Wait that subs is cleaned
1036         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1037 }
1038
1039 //-----------------------------------------------------------------------------
1040 // TestSubDelReqTwoRetriesNoRespInSubmgr
1041 //
1042 //   stub                          stub
1043 // +-------+     +---------+    +---------+
1044 // | xapp  |     | submgr  |    | e2term  |
1045 // +-------+     +---------+    +---------+
1046 //     |              |              |
1047 //     |         [SUBS CREATE]       |
1048 //     |              |              |
1049 //     |              |              |
1050 //     | SubDelReq    |              |
1051 //     |------------->|              |
1052 //     |              |              |
1053 //     |              | SubDelReq    |
1054 //     |              |------------->|
1055 //     |              |              |
1056 //     |              | SubDelReq    |
1057 //     |              |------------->|
1058 //     |              |              |
1059 //     |              |              |
1060 //     |   SubDelResp |              |
1061 //     |<-------------|              |
1062 //
1063 //-----------------------------------------------------------------------------
1064
1065 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1066
1067         xapp.Logger.Info("TestSubDelReTwoRetriesNoRespInSubmgr start")
1068
1069         // Subs Create
1070         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1071         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1072         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1073         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1074
1075         // Subs Delete
1076         // Xapp: Send SubsDelReq
1077         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1078
1079         // E2t: Receive 1st SubsDelReq
1080         e2termConn.handle_e2term_subs_del_req(t)
1081
1082         // E2t: Receive 2nd SubsDelReq
1083         e2termConn.handle_e2term_subs_del_req(t)
1084
1085         // Xapp: Receive SubsDelReq
1086         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1087
1088         // Wait that subs is cleaned
1089         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1090 }