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("(%s) handle_xapp_subs_req", xappConn.desc)
  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 := &RMRParams{&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("(%s) handle_xapp_subs_resp", xappConn.desc)
 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                 xappConn.DecMsgCnt()
 119                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_RESP"] {
 120                         testError(t, "(%s) Received RIC_SUB_RESP wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_RESP", xapp.RicMessageTypeToName[msg.Mtype])
 121                         return -1
 122                 } else if msg.Xid != trans.xid {
 123                         testError(t, "(%s) Received RIC_SUB_RESP wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid)
 124                         return -1
 125                 } else {
 126                         packedData := &packer.PackedData{}
 127                         packedData.Buf = msg.Payload
 128                         e2SubsId = msg.SubId
 129                         unpackerr := e2SubsResp.UnPack(packedData)
 130
 131                         if unpackerr != nil {
 132                                 testError(t, "(%s) RIC_SUB_RESP unpack failed err: %s", xappConn.desc, unpackerr.Error())
 133                         }
 134                         geterr, resp := e2SubsResp.Get()
 135                         if geterr != nil {
 136                                 testError(t, "(%s) RIC_SUB_RESP get failed err: %s", xappConn.desc, geterr.Error())
 137                         }
 138
 139                         xapp.Logger.Info("(%s) Recv Subs Resp rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.desc, msg.Xid, msg.SubId, resp.RequestId.Seq)
 140                         return e2SubsId
 141                 }
 142         case <-time.After(15 * time.Second):
 143                 testError(t, "(%s) Not Received RIC_SUB_RESP within 15 secs", xappConn.desc)
 144                 return -1
 145         }
 146         return -1
 147 }
 148
 149 //-----------------------------------------------------------------------------
 150 //
 151 //-----------------------------------------------------------------------------
 152 func (xappConn *testingXappControl) handle_xapp_subs_fail(t *testing.T, trans *xappTransaction) int {
 153         xapp.Logger.Info("(%s) handle_xapp_subs_fail", xappConn.desc)
 154         e2SubsFail := e2asnpacker.NewPackerSubscriptionFailure()
 155         var e2SubsId int
 156
 157         //-------------------------------
 158         // xapp activity: Recv Subs Fail
 159         //-------------------------------
 160         select {
 161         case msg := <-xappConn.rmrConChan:
 162                 xappConn.DecMsgCnt()
 163                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_FAILURE"] {
 164                         testError(t, "(%s) Received RIC_SUB_FAILURE wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_FAILURE", xapp.RicMessageTypeToName[msg.Mtype])
 165                         return -1
 166                 } else if msg.Xid != trans.xid {
 167                         testError(t, "(%s) Received RIC_SUB_FAILURE wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid)
 168                         return -1
 169                 } else {
 170                         packedData := &packer.PackedData{}
 171                         packedData.Buf = msg.Payload
 172                         e2SubsId = msg.SubId
 173                         unpackerr := e2SubsFail.UnPack(packedData)
 174
 175                         if unpackerr != nil {
 176                                 testError(t, "(%s) RIC_SUB_FAILURE unpack failed err: %s", xappConn.desc, unpackerr.Error())
 177                         }
 178                         geterr, resp := e2SubsFail.Get()
 179                         if geterr != nil {
 180                                 testError(t, "(%s) RIC_SUB_FAILURE get failed err: %s", xappConn.desc, geterr.Error())
 181                         }
 182
 183                         xapp.Logger.Info("(%s) Recv Subs Fail rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.desc, msg.Xid, msg.SubId, resp.RequestId.Seq)
 184                         return e2SubsId
 185                 }
 186         case <-time.After(15 * time.Second):
 187                 testError(t, "(%s) Not Received RIC_SUB_FAILURE within 15 secs", xappConn.desc)
 188                 return -1
 189         }
 190         return -1
 191 }
 192
 193 //-----------------------------------------------------------------------------
 194 //
 195 //-----------------------------------------------------------------------------
 196 func (xappConn *testingXappControl) handle_xapp_subs_del_req(t *testing.T, oldTrans *xappTransaction, e2SubsId int) *xappTransaction {
 197         xapp.Logger.Info("(%s) handle_xapp_subs_del_req", xappConn.desc)
 198         e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
 199
 200         //---------------------------------
 201         // xapp activity: Send Subs Del Req
 202         //---------------------------------
 203         xapp.Logger.Info("(%s) Send Subs Del Req", xappConn.desc)
 204
 205         req := &e2ap.E2APSubscriptionDeleteRequest{}
 206         req.RequestId.Id = 1
 207         req.RequestId.Seq = uint32(e2SubsId)
 208         req.FunctionId = 1
 209
 210         e2SubsDelReq.Set(req)
 211         xapp.Logger.Debug("%s", e2SubsDelReq.String())
 212         err, packedMsg := e2SubsDelReq.Pack(nil)
 213         if err != nil {
 214                 testError(t, "(%s) pack NOK %s", xappConn.desc, err.Error())
 215                 return nil
 216         }
 217
 218         var trans *xappTransaction = oldTrans
 219         if trans == nil {
 220                 trans = xappConn.newXappTransaction(nil, "RAN_NAME_1")
 221         }
 222
 223         params := &RMRParams{&xapp.RMRParams{}}
 224         params.Mtype = xapp.RIC_SUB_DEL_REQ
 225         params.SubId = e2SubsId
 226         params.Payload = packedMsg.Buf
 227         params.Meid = trans.meid
 228         params.Xid = trans.xid
 229         params.Mbuf = nil
 230
 231         snderr := xappConn.RmrSend(params)
 232         if snderr != nil {
 233                 testError(t, "(%s) RMR SEND FAILED: %s", xappConn.desc, snderr.Error())
 234                 return nil
 235         }
 236         return trans
 237 }
 238
 239 //-----------------------------------------------------------------------------
 240 //
 241 //-----------------------------------------------------------------------------
 242 func (xappConn *testingXappControl) handle_xapp_subs_del_resp(t *testing.T, trans *xappTransaction) {
 243         xapp.Logger.Info("(%s) handle_xapp_subs_del_resp", xappConn.desc)
 244         e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
 245
 246         //---------------------------------
 247         // xapp activity: Recv Subs Del Resp
 248         //---------------------------------
 249         select {
 250         case msg := <-xappConn.rmrConChan:
 251                 xappConn.DecMsgCnt()
 252                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_RESP"] {
 253                         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])
 254                         return
 255                 } else if msg.Xid != trans.xid {
 256                         testError(t, "(%s) Received RIC_SUB_DEL_RESP wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid)
 257                         return
 258                 } else {
 259                         packedData := &packer.PackedData{}
 260                         packedData.Buf = msg.Payload
 261                         unpackerr := e2SubsDelResp.UnPack(packedData)
 262                         if unpackerr != nil {
 263                                 testError(t, "(%s) RIC_SUB_DEL_RESP unpack failed err: %s", xappConn.desc, unpackerr.Error())
 264                         }
 265                         geterr, resp := e2SubsDelResp.Get()
 266                         if geterr != nil {
 267                                 testError(t, "(%s) RIC_SUB_DEL_RESP get failed err: %s", xappConn.desc, geterr.Error())
 268                         }
 269                         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)
 270                         return
 271                 }
 272         case <-time.After(15 * time.Second):
 273                 testError(t, "(%s) Not Received RIC_SUB_DEL_RESP within 15 secs", xappConn.desc)
 274         }
 275 }
 276
 277 //-----------------------------------------------------------------------------
 278 //
 279 //-----------------------------------------------------------------------------
 280 func (e2termConn *testingE2termControl) handle_e2term_subs_req(t *testing.T) (*e2ap.E2APSubscriptionRequest, *RMRParams) {
 281         xapp.Logger.Info("(%s) handle_e2term_subs_req", e2termConn.desc)
 282         e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest()
 283
 284         //---------------------------------
 285         // e2term activity: Recv Subs Req
 286         //---------------------------------
 287         select {
 288         case msg := <-e2termConn.rmrConChan:
 289                 e2termConn.DecMsgCnt()
 290                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_REQ"] {
 291                         testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.desc, "RIC_SUB_REQ", xapp.RicMessageTypeToName[msg.Mtype])
 292                 } else {
 293                         xapp.Logger.Info("(%s) Recv Subs Req", e2termConn.desc)
 294                         packedData := &packer.PackedData{}
 295                         packedData.Buf = msg.Payload
 296                         unpackerr := e2SubsReq.UnPack(packedData)
 297                         if unpackerr != nil {
 298                                 testError(t, "(%s) RIC_SUB_REQ unpack failed err: %s", e2termConn.desc, unpackerr.Error())
 299                         }
 300                         geterr, req := e2SubsReq.Get()
 301                         if geterr != nil {
 302                                 testError(t, "(%s) RIC_SUB_REQ get failed err: %s", e2termConn.desc, geterr.Error())
 303                         }
 304                         return req, msg
 305                 }
 306         case <-time.After(15 * time.Second):
 307                 testError(t, "(%s) Not Received RIC_SUB_REQ within 15 secs", e2termConn.desc)
 308         }
 309         return nil, nil
 310 }
 311
 312 func (e2termConn *testingE2termControl) handle_e2term_subs_resp(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *RMRParams) {
 313         xapp.Logger.Info("(%s) handle_e2term_subs_resp", e2termConn.desc)
 314         e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse()
 315
 316         //---------------------------------
 317         // e2term activity: Send Subs Resp
 318         //---------------------------------
 319         xapp.Logger.Info("(%s) Send Subs Resp", e2termConn.desc)
 320
 321         resp := &e2ap.E2APSubscriptionResponse{}
 322
 323         resp.RequestId.Id = req.RequestId.Id
 324         resp.RequestId.Seq = req.RequestId.Seq
 325         resp.FunctionId = req.FunctionId
 326
 327         resp.ActionAdmittedList.Items = make([]e2ap.ActionAdmittedItem, len(req.ActionSetups))
 328         for index := int(0); index < len(req.ActionSetups); index++ {
 329                 resp.ActionAdmittedList.Items[index].ActionId = req.ActionSetups[index].ActionId
 330         }
 331
 332         for index := uint64(0); index < 1; index++ {
 333                 item := e2ap.ActionNotAdmittedItem{}
 334                 item.ActionId = index
 335                 item.Cause.Content = 1
 336                 item.Cause.CauseVal = 1
 337                 resp.ActionNotAdmittedList.Items = append(resp.ActionNotAdmittedList.Items, item)
 338         }
 339
 340         e2SubsResp.Set(resp)
 341         xapp.Logger.Debug("%s", e2SubsResp.String())
 342         packerr, packedMsg := e2SubsResp.Pack(nil)
 343         if packerr != nil {
 344                 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
 345         }
 346
 347         params := &RMRParams{&xapp.RMRParams{}}
 348         params.Mtype = xapp.RIC_SUB_RESP
 349         //params.SubId = msg.SubId
 350         params.SubId = -1
 351         params.Payload = packedMsg.Buf
 352         params.Meid = msg.Meid
 353         //params.Xid = msg.Xid
 354         params.Mbuf = nil
 355
 356         snderr := e2termConn.RmrSend(params)
 357         if snderr != nil {
 358                 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
 359         }
 360 }
 361
 362 //-----------------------------------------------------------------------------
 363 //
 364 //-----------------------------------------------------------------------------
 365 type test_subs_fail_params struct {
 366         req  *e2ap.E2APSubscriptionRequest
 367         fail *e2ap.E2APSubscriptionFailure
 368 }
 369
 370 func (p *test_subs_fail_params) Set(req *e2ap.E2APSubscriptionRequest) {
 371         p.req = req
 372
 373         p.fail = &e2ap.E2APSubscriptionFailure{}
 374         p.fail.RequestId.Id = p.req.RequestId.Id
 375         p.fail.RequestId.Seq = p.req.RequestId.Seq
 376         p.fail.FunctionId = p.req.FunctionId
 377         p.fail.ActionNotAdmittedList.Items = make([]e2ap.ActionNotAdmittedItem, len(p.req.ActionSetups))
 378         for index := int(0); index < len(p.fail.ActionNotAdmittedList.Items); index++ {
 379                 p.fail.ActionNotAdmittedList.Items[index].ActionId = p.req.ActionSetups[index].ActionId
 380                 p.SetCauseVal(index, 5, 1)
 381         }
 382 }
 383
 384 func (p *test_subs_fail_params) SetCauseVal(ind int, content uint8, causeval uint8) {
 385
 386         if ind < 0 {
 387                 for index := int(0); index < len(p.fail.ActionNotAdmittedList.Items); index++ {
 388                         p.fail.ActionNotAdmittedList.Items[index].Cause.Content = content
 389                         p.fail.ActionNotAdmittedList.Items[index].Cause.CauseVal = causeval
 390                 }
 391                 return
 392         }
 393         p.fail.ActionNotAdmittedList.Items[ind].Cause.Content = content
 394         p.fail.ActionNotAdmittedList.Items[ind].Cause.CauseVal = causeval
 395 }
 396
 397 func (e2termConn *testingE2termControl) handle_e2term_subs_fail(t *testing.T, fparams *test_subs_fail_params, msg *RMRParams) {
 398         xapp.Logger.Info("(%s) handle_e2term_subs_fail", e2termConn.desc)
 399         e2SubsFail := e2asnpacker.NewPackerSubscriptionFailure()
 400
 401         //---------------------------------
 402         // e2term activity: Send Subs Fail
 403         //---------------------------------
 404         xapp.Logger.Info("(%s) Send Subs Fail", e2termConn.desc)
 405
 406         e2SubsFail.Set(fparams.fail)
 407         xapp.Logger.Debug("%s", e2SubsFail.String())
 408         packerr, packedMsg := e2SubsFail.Pack(nil)
 409         if packerr != nil {
 410                 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
 411         }
 412
 413         params := &RMRParams{&xapp.RMRParams{}}
 414         params.Mtype = xapp.RIC_SUB_FAILURE
 415         params.SubId = msg.SubId
 416         params.Payload = packedMsg.Buf
 417         params.Meid = msg.Meid
 418         params.Xid = msg.Xid
 419         params.Mbuf = nil
 420
 421         snderr := e2termConn.RmrSend(params)
 422         if snderr != nil {
 423                 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
 424         }
 425 }
 426
 427 //-----------------------------------------------------------------------------
 428 //
 429 //-----------------------------------------------------------------------------
 430 func (e2termConn *testingE2termControl) handle_e2term_subs_del_req(t *testing.T) (*e2ap.E2APSubscriptionDeleteRequest, *RMRParams) {
 431         xapp.Logger.Info("(%s) handle_e2term_subs_del_req", e2termConn.desc)
 432         e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
 433
 434         //---------------------------------
 435         // e2term activity: Recv Subs Del Req
 436         //---------------------------------
 437         select {
 438         case msg := <-e2termConn.rmrConChan:
 439                 e2termConn.DecMsgCnt()
 440                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_REQ"] {
 441                         testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.desc, "RIC_SUB_DEL_REQ", xapp.RicMessageTypeToName[msg.Mtype])
 442                 } else {
 443                         xapp.Logger.Info("(%s) Recv Subs Del Req", e2termConn.desc)
 444
 445                         packedData := &packer.PackedData{}
 446                         packedData.Buf = msg.Payload
 447                         unpackerr := e2SubsDelReq.UnPack(packedData)
 448                         if unpackerr != nil {
 449                                 testError(t, "(%s) RIC_SUB_DEL_REQ unpack failed err: %s", e2termConn.desc, unpackerr.Error())
 450                         }
 451                         geterr, req := e2SubsDelReq.Get()
 452                         if geterr != nil {
 453                                 testError(t, "(%s) RIC_SUB_DEL_REQ get failed err: %s", e2termConn.desc, geterr.Error())
 454                         }
 455                         return req, msg
 456                 }
 457         case <-time.After(15 * time.Second):
 458                 testError(t, "(%s) Not Received RIC_SUB_DEL_REQ within 15 secs", e2termConn.desc)
 459         }
 460         return nil, nil
 461 }
 462
 463 func handle_e2term_recv_empty() bool {
 464         if len(e2termConn.rmrConChan) > 0 {
 465                 return false
 466         }
 467         return true
 468 }
 469
 470 func (e2termConn *testingE2termControl) handle_e2term_subs_del_resp(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *RMRParams) {
 471         xapp.Logger.Info("(%s) handle_e2term_subs_del_resp", e2termConn.desc)
 472         e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
 473
 474         //---------------------------------
 475         // e2term activity: Send Subs Del Resp
 476         //---------------------------------
 477         xapp.Logger.Info("(%s) Send Subs Del Resp", e2termConn.desc)
 478
 479         resp := &e2ap.E2APSubscriptionDeleteResponse{}
 480         resp.RequestId.Id = req.RequestId.Id
 481         resp.RequestId.Seq = req.RequestId.Seq
 482         resp.FunctionId = req.FunctionId
 483
 484         e2SubsDelResp.Set(resp)
 485         xapp.Logger.Debug("%s", e2SubsDelResp.String())
 486         packerr, packedMsg := e2SubsDelResp.Pack(nil)
 487         if packerr != nil {
 488                 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
 489         }
 490
 491         params := &RMRParams{&xapp.RMRParams{}}
 492         params.Mtype = xapp.RIC_SUB_DEL_RESP
 493         params.SubId = msg.SubId
 494         params.Payload = packedMsg.Buf
 495         params.Meid = msg.Meid
 496         params.Xid = msg.Xid
 497         params.Mbuf = nil
 498
 499         snderr := e2termConn.RmrSend(params)
 500         if snderr != nil {
 501                 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
 502         }
 503 }
 504
 505 //-----------------------------------------------------------------------------
 506 //
 507 //-----------------------------------------------------------------------------
 508 func (e2termConn *testingE2termControl) handle_e2term_subs_del_fail(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *RMRParams) {
 509         xapp.Logger.Info("(%s) handle_e2term_del_subs_fail", e2termConn.desc)
 510         e2SubsDelFail := e2asnpacker.NewPackerSubscriptionDeleteFailure()
 511
 512         //---------------------------------
 513         // e2term activity: Send Subs Del Fail
 514         //---------------------------------
 515         xapp.Logger.Info("(%s) Send Subs Del Fail", e2termConn.desc)
 516
 517         resp := &e2ap.E2APSubscriptionDeleteFailure{}
 518         resp.RequestId.Id = req.RequestId.Id
 519         resp.RequestId.Seq = req.RequestId.Seq
 520         resp.FunctionId = req.FunctionId
 521         resp.Cause.Content = 3  // CauseMisc
 522         resp.Cause.CauseVal = 4 // unspecified
 523
 524         e2SubsDelFail.Set(resp)
 525         xapp.Logger.Debug("%s", e2SubsDelFail.String())
 526         packerr, packedMsg := e2SubsDelFail.Pack(nil)
 527         if packerr != nil {
 528                 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
 529         }
 530
 531         params := &RMRParams{&xapp.RMRParams{}}
 532         params.Mtype = xapp.RIC_SUB_DEL_FAILURE
 533         params.SubId = msg.SubId
 534         params.Payload = packedMsg.Buf
 535         params.Meid = msg.Meid
 536         params.Xid = msg.Xid
 537         params.Mbuf = nil
 538
 539         snderr := e2termConn.RmrSend(params)
 540         if snderr != nil {
 541                 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
 542         }
 543 }
 544
 545 //-----------------------------------------------------------------------------
 546 //
 547 //-----------------------------------------------------------------------------
 548 func (mc *testingMainControl) wait_subs_clean(t *testing.T, e2SubsId int, secs int) bool {
 549         var subs *Subscription
 550         i := 1
 551         for ; i <= secs*2; i++ {
 552                 subs = mc.c.registry.GetSubscription(uint16(e2SubsId))
 553                 if subs == nil {
 554                         return true
 555                 }
 556                 time.Sleep(500 * time.Millisecond)
 557         }
 558         if subs != nil {
 559                 testError(t, "(general) no clean within %d secs: %s", secs, subs.String())
 560         } else {
 561                 testError(t, "(general) no clean within %d secs: subs(N/A)", secs)
 562         }
 563         return false
 564 }
 565
 566 func (mc *testingMainControl) wait_subs_trans_clean(t *testing.T, e2SubsId int, secs int) bool {
 567         var trans *Transaction
 568         i := 1
 569         for ; i <= secs*2; i++ {
 570                 subs := mc.c.registry.GetSubscription(uint16(e2SubsId))
 571                 if subs == nil {
 572                         return true
 573                 }
 574                 trans = subs.GetTransaction()
 575                 if trans == nil {
 576                         return true
 577                 }
 578                 time.Sleep(500 * time.Millisecond)
 579         }
 580         if trans != nil {
 581                 testError(t, "(general) no clean within %d secs: %s", secs, trans.String())
 582         } else {
 583                 testError(t, "(general) no clean within %d secs: trans(N/A)", secs)
 584         }
 585         return false
 586 }
 587
 588 func (mc *testingMainControl) get_subid(t *testing.T) uint16 {
 589         mc.c.registry.mutex.Lock()
 590         defer mc.c.registry.mutex.Unlock()
 591         return mc.c.registry.subIds[0]
 592 }
 593
 594 func (mc *testingMainControl) wait_subid_change(t *testing.T, origSubId uint16, secs int) (uint16, bool) {
 595         i := 1
 596         for ; i <= secs*2; i++ {
 597                 mc.c.registry.mutex.Lock()
 598                 currSubId := mc.c.registry.subIds[0]
 599                 mc.c.registry.mutex.Unlock()
 600                 if currSubId != origSubId {
 601                         return currSubId, true
 602                 }
 603                 time.Sleep(500 * time.Millisecond)
 604         }
 605         testError(t, "(general) no subId change within %d secs", secs)
 606         return 0, false
 607 }
 608
 609 func (mc *testingMainControl) get_msgcounter(t *testing.T) uint64 {
 610         return mc.c.msgCounter
 611 }
 612
 613 func (mc *testingMainControl) wait_msgcounter_change(t *testing.T, orig uint64, secs int) (uint64, bool) {
 614         i := 1
 615         for ; i <= secs*2; i++ {
 616                 curr := mc.c.msgCounter
 617                 if curr != orig {
 618                         return curr, true
 619                 }
 620                 time.Sleep(500 * time.Millisecond)
 621         }
 622         testError(t, "(general) no msg counter change within %d secs", secs)
 623         return 0, false
 624 }
 625
 626 //-----------------------------------------------------------------------------
 627 // TestSubReqAndRouteNok
 628 //
 629 //   stub                          stub
 630 // +-------+     +---------+    +---------+
 631 // | xapp  |     | submgr  |    | rtmgr   |
 632 // +-------+     +---------+    +---------+
 633 //     |              |              |
 634 //     | SubReq       |              |
 635 //     |------------->|              |
 636 //     |              |              |
 637 //     |              | RouteCreate  |
 638 //     |              |------------->|
 639 //     |              |              |
 640 //     |              | RouteCreate  |
 641 //     |              |  status:400  |
 642 //     |              |<-------------|
 643 //     |              |              |
 644 //     |       [SUBS INT DELETE]     |
 645 //     |              |              |
 646 //
 647 //-----------------------------------------------------------------------------
 648
 649 func TestSubReqAndRouteNok(t *testing.T) {
 650         xapp.Logger.Info("TestSubReqAndRouteNok")
 651
 652         waiter := rtmgrHttp.AllocNextEvent(false)
 653         newSubsId := mainCtrl.get_subid(t)
 654         xappConn1.handle_xapp_subs_req(t, nil)
 655         waiter.WaitResult(t)
 656
 657         //Wait that subs is cleaned
 658         mainCtrl.wait_subs_clean(t, int(newSubsId), 10)
 659
 660         xappConn1.TestMsgCnt(t)
 661         xappConn2.TestMsgCnt(t)
 662         e2termConn.TestMsgCnt(t)
 663 }
 664
 665 //-----------------------------------------------------------------------------
 666 // TestSubReqAndSubDelOk
 667 //
 668 //   stub                          stub
 669 // +-------+     +---------+    +---------+
 670 // | xapp  |     | submgr  |    | e2term  |
 671 // +-------+     +---------+    +---------+
 672 //     |              |              |
 673 //     | SubReq       |              |
 674 //     |------------->|              |
 675 //     |              |              |
 676 //     |              | SubReq       |
 677 //     |              |------------->|
 678 //     |              |              |
 679 //     |              |      SubResp |
 680 //     |              |<-------------|
 681 //     |              |              |
 682 //     |      SubResp |              |
 683 //     |<-------------|              |
 684 //     |              |              |
 685 //     |              |              |
 686 //     | SubDelReq    |              |
 687 //     |------------->|              |
 688 //     |              |              |
 689 //     |              | SubDelReq    |
 690 //     |              |------------->|
 691 //     |              |              |
 692 //     |              |   SubDelResp |
 693 //     |              |<-------------|
 694 //     |              |              |
 695 //     |   SubDelResp |              |
 696 //     |<-------------|              |
 697 //
 698 //-----------------------------------------------------------------------------
 699 func TestSubReqAndSubDelOk(t *testing.T) {
 700         xapp.Logger.Info("TestSubReqAndSubDelOk")
 701
 702         waiter := rtmgrHttp.AllocNextEvent(true)
 703         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 704         waiter.WaitResult(t)
 705
 706         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 707         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 708         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 709         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 710         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 711
 712         waiter = rtmgrHttp.AllocNextEvent(true)
 713         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 714         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 715         waiter.WaitResult(t)
 716
 717         //Wait that subs is cleaned
 718         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 719
 720         xappConn1.TestMsgCnt(t)
 721         xappConn2.TestMsgCnt(t)
 722         e2termConn.TestMsgCnt(t)
 723 }
 724
 725 //-----------------------------------------------------------------------------
 726 // TestSubReqRetransmission
 727 //
 728 //   stub                          stub
 729 // +-------+     +---------+    +---------+
 730 // | xapp  |     | submgr  |    | e2term  |
 731 // +-------+     +---------+    +---------+
 732 //     |              |              |
 733 //     |  SubReq      |              |
 734 //     |------------->|              |
 735 //     |              |              |
 736 //     |              | SubReq       |
 737 //     |              |------------->|
 738 //     |              |              |
 739 //     |  SubReq      |              |
 740 //     | (retrans)    |              |
 741 //     |------------->|              |
 742 //     |              |              |
 743 //     |              |      SubResp |
 744 //     |              |<-------------|
 745 //     |              |              |
 746 //     |      SubResp |              |
 747 //     |<-------------|              |
 748 //     |              |              |
 749 //     |         [SUBS DELETE]       |
 750 //     |              |              |
 751 //
 752 //-----------------------------------------------------------------------------
 753 func TestSubReqRetransmission(t *testing.T) {
 754         xapp.Logger.Info("TestSubReqRetransmission")
 755
 756         //Subs Create
 757         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 758         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 759
 760         seqBef := mainCtrl.get_msgcounter(t)
 761         xappConn1.handle_xapp_subs_req(t, cretrans) //Retransmitted SubReq
 762         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 763
 764         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 765         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 766
 767         //Subs Delete
 768         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 769         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 770         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 771         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 772
 773         //Wait that subs is cleaned
 774         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 775
 776         xappConn1.TestMsgCnt(t)
 777         xappConn2.TestMsgCnt(t)
 778         e2termConn.TestMsgCnt(t)
 779 }
 780
 781 //-----------------------------------------------------------------------------
 782 // TestSubDelReqRetransmission
 783 //
 784 //   stub                          stub
 785 // +-------+     +---------+    +---------+
 786 // | xapp  |     | submgr  |    | e2term  |
 787 // +-------+     +---------+    +---------+
 788 //     |              |              |
 789 //     |         [SUBS CREATE]       |
 790 //     |              |              |
 791 //     |              |              |
 792 //     | SubDelReq    |              |
 793 //     |------------->|              |
 794 //     |              |              |
 795 //     |              | SubDelReq    |
 796 //     |              |------------->|
 797 //     |              |              |
 798 //     | SubDelReq    |              |
 799 //     | (same sub)   |              |
 800 //     | (same xid)   |              |
 801 //     |------------->|              |
 802 //     |              |              |
 803 //     |              |   SubDelResp |
 804 //     |              |<-------------|
 805 //     |              |              |
 806 //     |   SubDelResp |              |
 807 //     |<-------------|              |
 808 //
 809 //-----------------------------------------------------------------------------
 810 func TestSubDelReqRetransmission(t *testing.T) {
 811         xapp.Logger.Info("TestSubDelReqRetransmission")
 812
 813         //Subs Create
 814         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 815         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 816         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 817         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 818
 819         //Subs Delete
 820         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 821         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 822
 823         seqBef := mainCtrl.get_msgcounter(t)
 824         xappConn1.handle_xapp_subs_del_req(t, deltrans, e2SubsId) //Retransmitted SubDelReq
 825         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 826
 827         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 828         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 829
 830         //Wait that subs is cleaned
 831         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 832
 833         xappConn1.TestMsgCnt(t)
 834         xappConn2.TestMsgCnt(t)
 835         e2termConn.TestMsgCnt(t)
 836 }
 837
 838 //-----------------------------------------------------------------------------
 839 // TestSubDelReqCollision
 840 //
 841 //   stub                          stub
 842 // +-------+     +---------+    +---------+
 843 // | xapp  |     | submgr  |    | e2term  |
 844 // +-------+     +---------+    +---------+
 845 //     |              |              |
 846 //     |         [SUBS CREATE]       |
 847 //     |              |              |
 848 //     |              |              |
 849 //     | SubDelReq    |              |
 850 //     |------------->|              |
 851 //     |              |              |
 852 //     |              | SubDelReq    |
 853 //     |              |------------->|
 854 //     |              |              |
 855 //     | SubDelReq    |              |
 856 //     | (same sub)   |              |
 857 //     | (diff xid)   |              |
 858 //     |------------->|              |
 859 //     |              |              |
 860 //     |              |   SubDelResp |
 861 //     |              |<-------------|
 862 //     |              |              |
 863 //     |   SubDelResp |              |
 864 //     |<-------------|              |
 865 //
 866 //-----------------------------------------------------------------------------
 867 func TestSubDelReqCollision(t *testing.T) {
 868         xapp.Logger.Info("TestSubDelReqCollision")
 869
 870         //Subs Create
 871         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
 872         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
 873         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
 874         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
 875
 876         //Subs Delete
 877         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
 878         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
 879
 880         seqBef := mainCtrl.get_msgcounter(t)
 881         deltranscol := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
 882         xappConn1.handle_xapp_subs_del_req(t, deltranscol, e2SubsId) //Colliding SubDelReq
 883         mainCtrl.wait_msgcounter_change(t, seqBef, 10)
 884
 885         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
 886         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
 887
 888         //Wait that subs is cleaned
 889         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
 890
 891         xappConn1.TestMsgCnt(t)
 892         xappConn2.TestMsgCnt(t)
 893         e2termConn.TestMsgCnt(t)
 894 }
 895
 896 //-----------------------------------------------------------------------------
 897 // TestSubReqAndSubDelOkTwoParallel
 898 //
 899 //   stub                          stub
 900 // +-------+     +---------+    +---------+
 901 // | xapp  |     | submgr  |    | e2term  |
 902 // +-------+     +---------+    +---------+
 903 //     |              |              |
 904 //     |              |              |
 905 //     |              |              |
 906 //     | SubReq1      |              |
 907 //     |------------->|              |
 908 //     |              |              |
 909 //     |              | SubReq1      |
 910 //     |              |------------->|
 911 //     |              |              |
 912 //     | SubReq2      |              |
 913 //     |------------->|              |
 914 //     |              |              |
 915 //     |              | SubReq2      |
 916 //     |              |------------->|
 917 //     |              |              |
 918 //     |              |    SubResp1  |
 919 //     |              |<-------------|
 920 //     |              |    SubResp2  |
 921 //     |              |<-------------|
 922 //     |              |              |
 923 //     |    SubResp1  |              |
 924 //     |<-------------|              |
 925 //     |    SubResp2  |              |
 926 //     |<-------------|              |
 927 //     |              |              |
 928 //     |        [SUBS 1 DELETE]      |
 929 //     |              |              |
 930 //     |        [SUBS 2 DELETE]      |
 931 //     |              |              |
 932 //
 933 //-----------------------------------------------------------------------------
 934 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
 935         xapp.Logger.Info("TestSubReqAndSubDelOkTwoParallel")
 936
 937         //Req1
 938         cretrans1 := xappConn1.handle_xapp_subs_req(t, nil)
 939         crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t)
 940
 941         //Req2
 942         cretrans2 := xappConn2.handle_xapp_subs_req(t, nil)
 943         crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t)
 944
 945         //Resp1
 946         e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1)
 947         e2SubsId1 := xappConn1.handle_xapp_subs_resp(t, cretrans1)
 948
 949         //Resp2
 950         e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2)
 951         e2SubsId2 := xappConn2.handle_xapp_subs_resp(t, cretrans2)
 952
 953         //Del1
 954         deltrans1 := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId1)
 955         delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t)
 956         e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1)
 957         xappConn1.handle_xapp_subs_del_resp(t, deltrans1)
 958         //Wait that subs is cleaned
 959         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
 960
 961         //Del2
 962         deltrans2 := xappConn2.handle_xapp_subs_del_req(t, nil, e2SubsId2)
 963         delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t)
 964         e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2)
 965         xappConn2.handle_xapp_subs_del_resp(t, deltrans2)
 966         //Wait that subs is cleaned
 967         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
 968
 969         xappConn1.TestMsgCnt(t)
 970         xappConn2.TestMsgCnt(t)
 971         e2termConn.TestMsgCnt(t)
 972 }
 973
 974 //-----------------------------------------------------------------------------
 975 // TestSameSubsDiffRan
 976 // Same subscription to different RANs
 977 //
 978 //   stub                          stub
 979 // +-------+     +---------+    +---------+
 980 // | xapp  |     | submgr  |    | e2term  |
 981 // +-------+     +---------+    +---------+
 982 //     |              |              |
 983 //     |              |              |
 984 //     |              |              |
 985 //     | SubReq(r1)   |              |
 986 //     |------------->|              |
 987 //     |              |              |
 988 //     |              | SubReq(r1)   |
 989 //     |              |------------->|
 990 //     |              |              |
 991 //     |              | SubResp(r1)  |
 992 //     |              |<-------------|
 993 //     |              |              |
 994 //     | SubResp(r1)  |              |
 995 //     |<-------------|              |
 996 //     |              |              |
 997 //     | SubReq(r2)   |              |
 998 //     |------------->|              |
 999 //     |              |              |
1000 //     |              | SubReq(r2)   |
1001 //     |              |------------->|
1002 //     |              |              |
1003 //     |              | SubResp(r2)  |
1004 //     |              |<-------------|
1005 //     |              |              |
1006 //     | SubResp(r2)  |              |
1007 //     |<-------------|              |
1008 //     |              |              |
1009 //     |       [SUBS r1 DELETE]      |
1010 //     |              |              |
1011 //     |       [SUBS r2 DELETE]      |
1012 //     |              |              |
1013 //
1014 //-----------------------------------------------------------------------------
1015 func TestSameSubsDiffRan(t *testing.T) {
1016         xapp.Logger.Info("TestSameSubsDiffRan")
1017
1018         //Req1
1019         cretrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
1020         xappConn1.handle_xapp_subs_req(t, cretrans1)
1021         crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t)
1022         e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1)
1023         e2SubsId1 := xappConn1.handle_xapp_subs_resp(t, cretrans1)
1024
1025         //Req2
1026         cretrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2")
1027         xappConn1.handle_xapp_subs_req(t, cretrans2)
1028         crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t)
1029         e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2)
1030         e2SubsId2 := xappConn1.handle_xapp_subs_resp(t, cretrans2)
1031
1032         //Del1
1033         deltrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1")
1034         xappConn1.handle_xapp_subs_del_req(t, deltrans1, e2SubsId1)
1035         delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t)
1036         e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1)
1037         xappConn1.handle_xapp_subs_del_resp(t, deltrans1)
1038         //Wait that subs is cleaned
1039         mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1040
1041         //Del2
1042         deltrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2")
1043         xappConn1.handle_xapp_subs_del_req(t, deltrans2, e2SubsId2)
1044         delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t)
1045         e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2)
1046         xappConn1.handle_xapp_subs_del_resp(t, deltrans2)
1047         //Wait that subs is cleaned
1048         mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1049
1050         xappConn1.TestMsgCnt(t)
1051         xappConn2.TestMsgCnt(t)
1052         e2termConn.TestMsgCnt(t)
1053 }
1054
1055 //-----------------------------------------------------------------------------
1056 // TestSubReqRetryInSubmgr
1057 //
1058 //   stub                          stub
1059 // +-------+     +---------+    +---------+
1060 // | xapp  |     | submgr  |    | e2term  |
1061 // +-------+     +---------+    +---------+
1062 //     |              |              |
1063 //     |  SubReq      |              |
1064 //     |------------->|              |
1065 //     |              |              |
1066 //     |              | SubReq       |
1067 //     |              |------------->|
1068 //     |              |              |
1069 //     |              |              |
1070 //     |              | SubReq       |
1071 //     |              |------------->|
1072 //     |              |              |
1073 //     |              |      SubResp |
1074 //     |              |<-------------|
1075 //     |              |              |
1076 //     |      SubResp |              |
1077 //     |<-------------|              |
1078 //     |              |              |
1079 //     |         [SUBS DELETE]       |
1080 //     |              |              |
1081 //
1082 //-----------------------------------------------------------------------------
1083
1084 func TestSubReqRetryInSubmgr(t *testing.T) {
1085
1086         xapp.Logger.Info("TestSubReqRetryInSubmgr start")
1087
1088         // Xapp: Send SubsReq
1089         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1090
1091         // E2t: Receive 1st SubsReq
1092         e2termConn.handle_e2term_subs_req(t)
1093
1094         // E2t: Receive 2nd SubsReq and send SubsResp
1095         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1096         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1097
1098         // Xapp: Receive SubsResp
1099         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1100
1101         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1102         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1103         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
1104         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1105
1106         // Wait that subs is cleaned
1107         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1108
1109         xappConn1.TestMsgCnt(t)
1110         xappConn2.TestMsgCnt(t)
1111         e2termConn.TestMsgCnt(t)
1112 }
1113
1114 //-----------------------------------------------------------------------------
1115 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
1116 //
1117 //   stub                          stub
1118 // +-------+     +---------+    +---------+
1119 // | xapp  |     | submgr  |    | e2term  |
1120 // +-------+     +---------+    +---------+
1121 //     |              |              |
1122 //     |  SubReq      |              |
1123 //     |------------->|              |
1124 //     |              |              |
1125 //     |              | SubReq       |
1126 //     |              |------------->|
1127 //     |              |              |
1128 //     |              |              |
1129 //     |              | SubReq       |
1130 //     |              |------------->|
1131 //     |              |              |
1132 //     |              | SubDelReq    |
1133 //     |              |------------->|
1134 //     |              |              |
1135 //     |              |              |
1136 //     |              | SubDelReq    |
1137 //     |              |------------->|
1138 //     |              |              |
1139 //     |              |              |
1140 //     |              |   SubDelResp |
1141 //     |              |<-------------|
1142 //     |              |              |
1143 //
1144 //-----------------------------------------------------------------------------
1145
1146 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
1147
1148         xapp.Logger.Info("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
1149
1150         // Xapp: Send SubsReq
1151         xappConn1.handle_xapp_subs_req(t, nil)
1152
1153         // E2t: Receive 1st SubsReq
1154         e2termConn.handle_e2term_subs_req(t)
1155
1156         // E2t: Receive 2nd SubsReq
1157         e2termConn.handle_e2term_subs_req(t)
1158
1159         // E2t: Send receive SubsDelReq and send SubsResp
1160         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1161         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
1162
1163         // Wait that subs is cleaned
1164         mainCtrl.wait_subs_clean(t, int(delreq.RequestId.Seq), 10)
1165
1166         xappConn1.TestMsgCnt(t)
1167         xappConn2.TestMsgCnt(t)
1168         e2termConn.TestMsgCnt(t)
1169 }
1170
1171 //-----------------------------------------------------------------------------
1172 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
1173 //
1174 //   stub                          stub
1175 // +-------+     +---------+    +---------+
1176 // | xapp  |     | submgr  |    | e2term  |
1177 // +-------+     +---------+    +---------+
1178 //     |              |              |
1179 //     |  SubReq      |              |
1180 //     |------------->|              |
1181 //     |              |              |
1182 //     |              | SubReq       |
1183 //     |              |------------->|
1184 //     |              |              |
1185 //     |              |              |
1186 //     |              | SubReq       |
1187 //     |              |------------->|
1188 //     |              |              |
1189 //     |              | SubDelReq    |
1190 //     |              |------------->|
1191 //     |              |              |
1192 //     |              |              |
1193 //     |              | SubDelReq    |
1194 //     |              |------------->|
1195 //     |              |              |
1196 //     |              |              |
1197 //
1198 //-----------------------------------------------------------------------------
1199
1200 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
1201
1202         xapp.Logger.Info("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
1203
1204         // Xapp: Send SubsReq
1205         xappConn1.handle_xapp_subs_req(t, nil)
1206
1207         // E2t: Receive 1st SubsReq
1208         e2termConn.handle_e2term_subs_req(t)
1209
1210         // E2t: Receive 2nd SubsReq
1211         e2termConn.handle_e2term_subs_req(t)
1212
1213         // E2t: Receive 1st SubsDelReq
1214         e2termConn.handle_e2term_subs_del_req(t)
1215
1216         // E2t: Receive 2nd SubsDelReq
1217         delreq, _ := e2termConn.handle_e2term_subs_del_req(t)
1218
1219         // Wait that subs is cleaned
1220         mainCtrl.wait_subs_clean(t, int(delreq.RequestId.Seq), 15)
1221
1222         xappConn1.TestMsgCnt(t)
1223         xappConn2.TestMsgCnt(t)
1224         e2termConn.TestMsgCnt(t)
1225 }
1226
1227 //-----------------------------------------------------------------------------
1228 // TestSubReqSubFailRespInSubmgr
1229 //
1230 //   stub                          stub
1231 // +-------+     +---------+    +---------+
1232 // | xapp  |     | submgr  |    | e2term  |
1233 // +-------+     +---------+    +---------+
1234 //     |              |              |
1235 //     |  SubReq      |              |
1236 //     |------------->|              |
1237 //     |              |              |
1238 //     |              | SubReq       |
1239 //     |              |------------->|
1240 //     |              |              |
1241 //     |              |      SubFail |
1242 //     |              |<-------------|
1243 //     |              |              |
1244 //     |      SubFail |              |
1245 //     |<-------------|              |
1246 //     |              |              |
1247 //
1248 //-----------------------------------------------------------------------------
1249
1250 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1251
1252         xapp.Logger.Info("TestSubReqSubFailRespInSubmgr start")
1253
1254         // Xapp: Send SubsReq
1255         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1256
1257         // E2t: Receive SubsReq and send SubsFail
1258         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1259         fparams := &test_subs_fail_params{}
1260         fparams.Set(crereq)
1261         e2termConn.handle_e2term_subs_fail(t, fparams, cremsg)
1262
1263         // Xapp: Receive SubsFail
1264         e2SubsId := xappConn1.handle_xapp_subs_fail(t, cretrans)
1265
1266         // Wait that subs is cleaned
1267         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1268
1269         xappConn1.TestMsgCnt(t)
1270         xappConn2.TestMsgCnt(t)
1271         e2termConn.TestMsgCnt(t)
1272 }
1273
1274 //-----------------------------------------------------------------------------
1275 // TestSubDelReqRetryInSubmgr
1276 //
1277 //   stub                          stub
1278 // +-------+     +---------+    +---------+
1279 // | xapp  |     | submgr  |    | e2term  |
1280 // +-------+     +---------+    +---------+
1281 //     |              |              |
1282 //     |         [SUBS CREATE]       |
1283 //     |              |              |
1284 //     |              |              |
1285 //     | SubDelReq    |              |
1286 //     |------------->|              |
1287 //     |              |              |
1288 //     |              | SubDelReq    |
1289 //     |              |------------->|
1290 //     |              |              |
1291 //     |              | SubDelReq    |
1292 //     |              |------------->|
1293 //     |              |              |
1294 //     |              |   SubDelResp |
1295 //     |              |<-------------|
1296 //     |              |              |
1297 //     |   SubDelResp |              |
1298 //     |<-------------|              |
1299 //
1300 //-----------------------------------------------------------------------------
1301
1302 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1303
1304         xapp.Logger.Info("TestSubDelReqRetryInSubmgr start")
1305
1306         // Subs Create
1307         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1308         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1309         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1310         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1311
1312         // Subs Delete
1313         // Xapp: Send SubsDelReq
1314         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1315
1316         // E2t: Receive 1st SubsDelReq
1317         e2termConn.handle_e2term_subs_del_req(t)
1318
1319         // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1320         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1321         e2termConn.handle_e2term_subs_del_resp(t, delreq, delmsg)
1322
1323         // Xapp: Receive SubsDelResp
1324         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1325
1326         // Wait that subs is cleaned
1327         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1328
1329         xappConn1.TestMsgCnt(t)
1330         xappConn2.TestMsgCnt(t)
1331         e2termConn.TestMsgCnt(t)
1332 }
1333
1334 //-----------------------------------------------------------------------------
1335 // TestSubDelReqTwoRetriesNoRespInSubmgr
1336 //
1337 //   stub                          stub
1338 // +-------+     +---------+    +---------+
1339 // | xapp  |     | submgr  |    | e2term  |
1340 // +-------+     +---------+    +---------+
1341 //     |              |              |
1342 //     |         [SUBS CREATE]       |
1343 //     |              |              |
1344 //     |              |              |
1345 //     | SubDelReq    |              |
1346 //     |------------->|              |
1347 //     |              |              |
1348 //     |              | SubDelReq    |
1349 //     |              |------------->|
1350 //     |              |              |
1351 //     |              | SubDelReq    |
1352 //     |              |------------->|
1353 //     |              |              |
1354 //     |              |              |
1355 //     |   SubDelResp |              |
1356 //     |<-------------|              |
1357 //
1358 //-----------------------------------------------------------------------------
1359
1360 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1361
1362         xapp.Logger.Info("TestSubDelReTwoRetriesNoRespInSubmgr start")
1363
1364         // Subs Create
1365         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1366         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1367         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1368         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1369
1370         // Subs Delete
1371         // Xapp: Send SubsDelReq
1372         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1373
1374         // E2t: Receive 1st SubsDelReq
1375         e2termConn.handle_e2term_subs_del_req(t)
1376
1377         // E2t: Receive 2nd SubsDelReq
1378         e2termConn.handle_e2term_subs_del_req(t)
1379
1380         // Xapp: Receive SubsDelResp
1381         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1382
1383         // Wait that subs is cleaned
1384         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1385
1386         xappConn1.TestMsgCnt(t)
1387         xappConn2.TestMsgCnt(t)
1388         e2termConn.TestMsgCnt(t)
1389 }
1390
1391 //-----------------------------------------------------------------------------
1392 // TestSubDelReqSubDelFailRespInSubmgr
1393 //
1394 //   stub                          stub
1395 // +-------+     +---------+    +---------+
1396 // | xapp  |     | submgr  |    | e2term  |
1397 // +-------+     +---------+    +---------+
1398 //     |              |              |
1399 //     |         [SUBS CREATE]       |
1400 //     |              |              |
1401 //     |              |              |
1402 //     |  SubDelReq   |              |
1403 //     |------------->|              |
1404 //     |              |              |
1405 //     |              | SubDelReq    |
1406 //     |              |------------->|
1407 //     |              |              |
1408 //     |              |   SubDelFail |
1409 //     |              |<-------------|
1410 //     |              |              |
1411 //     |   SubDelResp |              |
1412 //     |<-------------|              |
1413 //     |              |              |
1414 //
1415 //-----------------------------------------------------------------------------
1416
1417 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1418
1419         xapp.Logger.Info("TestSubReqSubDelFailRespInSubmgr start")
1420
1421         // Subs Create
1422         cretrans := xappConn1.handle_xapp_subs_req(t, nil)
1423         crereq, cremsg := e2termConn.handle_e2term_subs_req(t)
1424         e2termConn.handle_e2term_subs_resp(t, crereq, cremsg)
1425         e2SubsId := xappConn1.handle_xapp_subs_resp(t, cretrans)
1426
1427         // Xapp: Send SubsDelReq
1428         deltrans := xappConn1.handle_xapp_subs_del_req(t, nil, e2SubsId)
1429
1430         // E2t: Send receive SubsDelReq and send SubsDelFail
1431         delreq, delmsg := e2termConn.handle_e2term_subs_del_req(t)
1432         e2termConn.handle_e2term_subs_del_fail(t, delreq, delmsg)
1433
1434         // Xapp: Receive SubsDelResp
1435         xappConn1.handle_xapp_subs_del_resp(t, deltrans)
1436
1437         // Wait that subs is cleaned
1438         mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1439
1440         xappConn1.TestMsgCnt(t)
1441         xappConn2.TestMsgCnt(t)
1442         e2termConn.TestMsgCnt(t)
1443 }