pkg/control/ut_stub_e2term_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 e2t_e2asnpacker e2ap.E2APPackerIf = e2ap_wrapper.NewAsn1E2Packer()
  35
  36 //-----------------------------------------------------------------------------
  37 //
  38 //-----------------------------------------------------------------------------
  39 type testingE2termStub struct {
  40         testingRmrStubControl
  41 }
  42
  43 //-----------------------------------------------------------------------------
  44 //
  45 //-----------------------------------------------------------------------------
  46 func createNewE2termStub(desc string, rtfile string, port string, stat string) *testingE2termStub {
  47         e2termCtrl := &testingE2termStub{}
  48         e2termCtrl.testingRmrStubControl.init(desc, rtfile, port, stat, e2termCtrl)
  49         return e2termCtrl
  50 }
  51
  52 //-----------------------------------------------------------------------------
  53 //
  54 //-----------------------------------------------------------------------------
  55 func (tc *testingE2termStub) Consume(params *xapp.RMRParams) (err error) {
  56         xapp.Rmr.Free(params.Mbuf)
  57         params.Mbuf = nil
  58         msg := &RMRParams{params}
  59
  60         if params.Mtype == 55555 {
  61                 xapp.Logger.Info("(%s) Testing message ignore %s", tc.desc, msg.String())
  62                 tc.active = true
  63                 return
  64         }
  65
  66         xapp.Logger.Info("(%s) Consume %s", tc.desc, msg.String())
  67         tc.rmrConChan <- msg
  68         return
  69 }
  70
  71 //-----------------------------------------------------------------------------
  72 //
  73 //-----------------------------------------------------------------------------
  74 func (e2termConn *testingE2termStub) handle_e2term_subs_req(t *testing.T) (*e2ap.E2APSubscriptionRequest, *RMRParams) {
  75         xapp.Logger.Info("(%s) handle_e2term_subs_req", e2termConn.desc)
  76         e2SubsReq := e2t_e2asnpacker.NewPackerSubscriptionRequest()
  77
  78         //---------------------------------
  79         // e2term activity: Recv Subs Req
  80         //---------------------------------
  81         select {
  82         case msg := <-e2termConn.rmrConChan:
  83                 e2termConn.DecMsgCnt()
  84                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_REQ"] {
  85                         testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.desc, "RIC_SUB_REQ", xapp.RicMessageTypeToName[msg.Mtype])
  86                 } else {
  87                         xapp.Logger.Info("(%s) Recv Subs Req", e2termConn.desc)
  88                         packedData := &packer.PackedData{}
  89                         packedData.Buf = msg.Payload
  90                         unpackerr := e2SubsReq.UnPack(packedData)
  91                         if unpackerr != nil {
  92                                 testError(t, "(%s) RIC_SUB_REQ unpack failed err: %s", e2termConn.desc, unpackerr.Error())
  93                         }
  94                         geterr, req := e2SubsReq.Get()
  95                         if geterr != nil {
  96                                 testError(t, "(%s) RIC_SUB_REQ get failed err: %s", e2termConn.desc, geterr.Error())
  97                         }
  98                         return req, msg
  99                 }
 100         case <-time.After(15 * time.Second):
 101                 testError(t, "(%s) Not Received RIC_SUB_REQ within 15 secs", e2termConn.desc)
 102         }
 103         return nil, nil
 104 }
 105
 106 func (e2termConn *testingE2termStub) handle_e2term_subs_resp(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *RMRParams) {
 107         xapp.Logger.Info("(%s) handle_e2term_subs_resp", e2termConn.desc)
 108         e2SubsResp := e2t_e2asnpacker.NewPackerSubscriptionResponse()
 109
 110         //---------------------------------
 111         // e2term activity: Send Subs Resp
 112         //---------------------------------
 113         xapp.Logger.Info("(%s) Send Subs Resp", e2termConn.desc)
 114
 115         resp := &e2ap.E2APSubscriptionResponse{}
 116
 117         resp.RequestId.Id = req.RequestId.Id
 118         resp.RequestId.Seq = req.RequestId.Seq
 119         resp.FunctionId = req.FunctionId
 120
 121         resp.ActionAdmittedList.Items = make([]e2ap.ActionAdmittedItem, len(req.ActionSetups))
 122         for index := int(0); index < len(req.ActionSetups); index++ {
 123                 resp.ActionAdmittedList.Items[index].ActionId = req.ActionSetups[index].ActionId
 124         }
 125
 126         for index := uint64(0); index < 1; index++ {
 127                 item := e2ap.ActionNotAdmittedItem{}
 128                 item.ActionId = index
 129                 item.Cause.Content = 1
 130                 item.Cause.CauseVal = 1
 131                 resp.ActionNotAdmittedList.Items = append(resp.ActionNotAdmittedList.Items, item)
 132         }
 133
 134         e2SubsResp.Set(resp)
 135         xapp.Logger.Debug("%s", e2SubsResp.String())
 136         packerr, packedMsg := e2SubsResp.Pack(nil)
 137         if packerr != nil {
 138                 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
 139         }
 140
 141         params := &RMRParams{&xapp.RMRParams{}}
 142         params.Mtype = xapp.RIC_SUB_RESP
 143         //params.SubId = msg.SubId
 144         params.SubId = -1
 145         params.Payload = packedMsg.Buf
 146         params.Meid = msg.Meid
 147         //params.Xid = msg.Xid
 148         params.Mbuf = nil
 149
 150         snderr := e2termConn.RmrSend(params)
 151         if snderr != nil {
 152                 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
 153         }
 154 }
 155
 156 //-----------------------------------------------------------------------------
 157 //
 158 //-----------------------------------------------------------------------------
 159 type test_subs_fail_params struct {
 160         req  *e2ap.E2APSubscriptionRequest
 161         fail *e2ap.E2APSubscriptionFailure
 162 }
 163
 164 func (p *test_subs_fail_params) Set(req *e2ap.E2APSubscriptionRequest) {
 165         p.req = req
 166
 167         p.fail = &e2ap.E2APSubscriptionFailure{}
 168         p.fail.RequestId.Id = p.req.RequestId.Id
 169         p.fail.RequestId.Seq = p.req.RequestId.Seq
 170         p.fail.FunctionId = p.req.FunctionId
 171         p.fail.ActionNotAdmittedList.Items = make([]e2ap.ActionNotAdmittedItem, len(p.req.ActionSetups))
 172         for index := int(0); index < len(p.fail.ActionNotAdmittedList.Items); index++ {
 173                 p.fail.ActionNotAdmittedList.Items[index].ActionId = p.req.ActionSetups[index].ActionId
 174                 p.SetCauseVal(index, 5, 1)
 175         }
 176 }
 177
 178 func (p *test_subs_fail_params) SetCauseVal(ind int, content uint8, causeval uint8) {
 179
 180         if ind < 0 {
 181                 for index := int(0); index < len(p.fail.ActionNotAdmittedList.Items); index++ {
 182                         p.fail.ActionNotAdmittedList.Items[index].Cause.Content = content
 183                         p.fail.ActionNotAdmittedList.Items[index].Cause.CauseVal = causeval
 184                 }
 185                 return
 186         }
 187         p.fail.ActionNotAdmittedList.Items[ind].Cause.Content = content
 188         p.fail.ActionNotAdmittedList.Items[ind].Cause.CauseVal = causeval
 189 }
 190
 191 func (e2termConn *testingE2termStub) handle_e2term_subs_fail(t *testing.T, fparams *test_subs_fail_params, msg *RMRParams) {
 192         xapp.Logger.Info("(%s) handle_e2term_subs_fail", e2termConn.desc)
 193         e2SubsFail := e2t_e2asnpacker.NewPackerSubscriptionFailure()
 194
 195         //---------------------------------
 196         // e2term activity: Send Subs Fail
 197         //---------------------------------
 198         xapp.Logger.Info("(%s) Send Subs Fail", e2termConn.desc)
 199
 200         e2SubsFail.Set(fparams.fail)
 201         xapp.Logger.Debug("%s", e2SubsFail.String())
 202         packerr, packedMsg := e2SubsFail.Pack(nil)
 203         if packerr != nil {
 204                 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
 205         }
 206
 207         params := &RMRParams{&xapp.RMRParams{}}
 208         params.Mtype = xapp.RIC_SUB_FAILURE
 209         params.SubId = msg.SubId
 210         params.Payload = packedMsg.Buf
 211         params.Meid = msg.Meid
 212         params.Xid = msg.Xid
 213         params.Mbuf = nil
 214
 215         snderr := e2termConn.RmrSend(params)
 216         if snderr != nil {
 217                 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
 218         }
 219 }
 220
 221 //-----------------------------------------------------------------------------
 222 //
 223 //-----------------------------------------------------------------------------
 224 func (e2termConn *testingE2termStub) handle_e2term_subs_del_req(t *testing.T) (*e2ap.E2APSubscriptionDeleteRequest, *RMRParams) {
 225         xapp.Logger.Info("(%s) handle_e2term_subs_del_req", e2termConn.desc)
 226         e2SubsDelReq := e2t_e2asnpacker.NewPackerSubscriptionDeleteRequest()
 227
 228         //---------------------------------
 229         // e2term activity: Recv Subs Del Req
 230         //---------------------------------
 231         select {
 232         case msg := <-e2termConn.rmrConChan:
 233                 e2termConn.DecMsgCnt()
 234                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_REQ"] {
 235                         testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.desc, "RIC_SUB_DEL_REQ", xapp.RicMessageTypeToName[msg.Mtype])
 236                 } else {
 237                         xapp.Logger.Info("(%s) Recv Subs Del Req", e2termConn.desc)
 238
 239                         packedData := &packer.PackedData{}
 240                         packedData.Buf = msg.Payload
 241                         unpackerr := e2SubsDelReq.UnPack(packedData)
 242                         if unpackerr != nil {
 243                                 testError(t, "(%s) RIC_SUB_DEL_REQ unpack failed err: %s", e2termConn.desc, unpackerr.Error())
 244                         }
 245                         geterr, req := e2SubsDelReq.Get()
 246                         if geterr != nil {
 247                                 testError(t, "(%s) RIC_SUB_DEL_REQ get failed err: %s", e2termConn.desc, geterr.Error())
 248                         }
 249                         return req, msg
 250                 }
 251         case <-time.After(15 * time.Second):
 252                 testError(t, "(%s) Not Received RIC_SUB_DEL_REQ within 15 secs", e2termConn.desc)
 253         }
 254         return nil, nil
 255 }
 256
 257 func handle_e2term_recv_empty() bool {
 258         if len(e2termConn.rmrConChan) > 0 {
 259                 return false
 260         }
 261         return true
 262 }
 263
 264 func (e2termConn *testingE2termStub) handle_e2term_subs_del_resp(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *RMRParams) {
 265         xapp.Logger.Info("(%s) handle_e2term_subs_del_resp", e2termConn.desc)
 266         e2SubsDelResp := e2t_e2asnpacker.NewPackerSubscriptionDeleteResponse()
 267
 268         //---------------------------------
 269         // e2term activity: Send Subs Del Resp
 270         //---------------------------------
 271         xapp.Logger.Info("(%s) Send Subs Del Resp", e2termConn.desc)
 272
 273         resp := &e2ap.E2APSubscriptionDeleteResponse{}
 274         resp.RequestId.Id = req.RequestId.Id
 275         resp.RequestId.Seq = req.RequestId.Seq
 276         resp.FunctionId = req.FunctionId
 277
 278         e2SubsDelResp.Set(resp)
 279         xapp.Logger.Debug("%s", e2SubsDelResp.String())
 280         packerr, packedMsg := e2SubsDelResp.Pack(nil)
 281         if packerr != nil {
 282                 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
 283         }
 284
 285         params := &RMRParams{&xapp.RMRParams{}}
 286         params.Mtype = xapp.RIC_SUB_DEL_RESP
 287         params.SubId = msg.SubId
 288         params.Payload = packedMsg.Buf
 289         params.Meid = msg.Meid
 290         params.Xid = msg.Xid
 291         params.Mbuf = nil
 292
 293         snderr := e2termConn.RmrSend(params)
 294         if snderr != nil {
 295                 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
 296         }
 297 }
 298
 299 //-----------------------------------------------------------------------------
 300 //
 301 //-----------------------------------------------------------------------------
 302 func (e2termConn *testingE2termStub) handle_e2term_subs_del_fail(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *RMRParams) {
 303         xapp.Logger.Info("(%s) handle_e2term_del_subs_fail", e2termConn.desc)
 304         e2SubsDelFail := e2t_e2asnpacker.NewPackerSubscriptionDeleteFailure()
 305
 306         //---------------------------------
 307         // e2term activity: Send Subs Del Fail
 308         //---------------------------------
 309         xapp.Logger.Info("(%s) Send Subs Del Fail", e2termConn.desc)
 310
 311         resp := &e2ap.E2APSubscriptionDeleteFailure{}
 312         resp.RequestId.Id = req.RequestId.Id
 313         resp.RequestId.Seq = req.RequestId.Seq
 314         resp.FunctionId = req.FunctionId
 315         resp.Cause.Content = 3  // CauseMisc
 316         resp.Cause.CauseVal = 4 // unspecified
 317
 318         e2SubsDelFail.Set(resp)
 319         xapp.Logger.Debug("%s", e2SubsDelFail.String())
 320         packerr, packedMsg := e2SubsDelFail.Pack(nil)
 321         if packerr != nil {
 322                 testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error())
 323         }
 324
 325         params := &RMRParams{&xapp.RMRParams{}}
 326         params.Mtype = xapp.RIC_SUB_DEL_FAILURE
 327         params.SubId = msg.SubId
 328         params.Payload = packedMsg.Buf
 329         params.Meid = msg.Meid
 330         params.Xid = msg.Xid
 331         params.Mbuf = nil
 332
 333         snderr := e2termConn.RmrSend(params)
 334         if snderr != nil {
 335                 testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error())
 336         }
 337 }