RSM/converters/resource_status_failure_unpacker_test.go

   1 /*******************************************************************************
   2  *
   3  *   Copyright (c) 2019 AT&T Intellectual Property.
   4  *
   5  *   Licensed under the Apache License, Version 2.0 (the "License");
   6  *   you may not use this file except in compliance with the License.
   7  *   You may obtain a copy of the License at
   8  *
   9  *       http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *   Unless required by applicable law or agreed to in writing, software
  12  *   distributed under the License is distributed on an "AS IS" BASIS,
  13  *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *   See the License for the specific language governing permissions and
  15  *   limitations under the License.
  16  *
  17  *******************************************************************************/
  18
  19 /*
  20 * This source code is part of the near-RT RIC (RAN Intelligent Controller)
  21 * platform project (RICP).
  22 */
  23
  24 package converters
  25
  26 import (
  27         "fmt"
  28         "rsm/e2pdus"
  29         "rsm/logger"
  30         "strings"
  31         "testing"
  32 )
  33
  34 /*
  35  * Unpack a response returned from RAN.
  36  * Verify it matches the want pdu.
  37  */
  38
  39 func TestResourceStatusFailureConverter(t *testing.T) {
  40         logger, _ := logger.InitLogger(logger.DebugLevel)
  41         unpacker := NewX2apPduUnpacker(logger, e2pdus.MaxAsn1CodecMessageBufferSize)
  42         rsFailureConverter := NewResourceStatusFailureConverter(unpacker)
  43
  44         var testCases = []struct {
  45                 response  string
  46                 packedPdu string
  47         }{
  48                 {
  49                         response: "ENB1_Measurement_ID: 15, ENB2_Measurement_ID: 13, MeasurementInitiationResults:[ CellId: 02f829:0007ab50, MeasurementFailureCauses: [ MeasurementFailedReportCharacteristics: 00000007  ]  ]",
  50                         /*
  51                                         UnsuccessfulOutcome ::= {
  52                                     procedureCode: 9
  53                                     criticality: 0 (reject)
  54                                     value: ResourceStatusFailure ::= {
  55                                         protocolIEs: ProtocolIE-Container ::= {
  56                                             ResourceStatusFailure-IEs ::= {
  57                                                 id: 39
  58                                                 criticality: 0 (reject)
  59                                                 value: 15
  60                                             }
  61                                             ResourceStatusFailure-IEs ::= {
  62                                                 id: 40
  63                                                 criticality: 0 (reject)
  64                                                 value: 13
  65                                             }
  66                                             ResourceStatusFailure-IEs ::= {
  67                                                 id: 5
  68                                                 criticality: 1 (ignore)
  69                                                 value: 1 (hardware-failure)
  70                                             }
  71                                             ResourceStatusFailure-IEs ::= {
  72                                                 id: 68
  73                                                 criticality: 1 (ignore)
  74                                                 value: CompleteFailureCauseInformation-List ::= {
  75                                                     ProtocolIE-Single-Container ::= {
  76                                                         id: 69
  77                                                         criticality: 1 (ignore)
  78                                                         value: CompleteFailureCauseInformation-Item ::= {
  79                                                             cell-ID: ECGI ::= {
  80                                                                 pLMN-Identity: 02 F8 29
  81                                                                 eUTRANcellIdentifier: 00 07 AB 50 (4 bits unused)
  82                                                             }
  83                                                             measurementFailureCause-List: MeasurementFailureCause-List ::= {
  84                                                                 ProtocolIE-Single-Container ::= {
  85                                                                     id: 67
  86                                                                     criticality: 1 (ignore)
  87                                                                     value: MeasurementFailureCause-Item ::= {
  88                                                                         measurementFailedReportCharacteristics: 00 00 00 07
  89                                                                         cause: 0 (transfer-syntax-error)
  90                                                                     }
  91                                                                 }
  92                                                             }
  93                                                         }
  94                                                     }
  95                                                 }
  96                                             }
  97                                         }
  98                                     }
  99                                 }*/
 100
 101                         packedPdu: "400900320000040027000300000e0028000300000c00054001620044401800004540130002f8290007ab500000434006000000000740",
 102                 },
 103                 {
 104                         response: "ENB1_Measurement_ID: 1, ENB2_Measurement_ID: 74, MeasurementInitiationResults:[  ]",
 105                         /*
 106                                 UnsuccessfulOutcome ::= {
 107                                     procedureCode: 9
 108                                     criticality: 0 (reject)
 109                                     value: ResourceStatusFailure ::= {
 110                                         protocolIEs: ProtocolIE-Container ::= {
 111                                             ResourceStatusFailure-IEs ::= {
 112                                                 id: 39
 113                                                 criticality: 0 (reject)
 114                                                 value: 1
 115                                             }
 116                                             ResourceStatusFailure-IEs ::= {
 117                                                 id: 40
 118                                                 criticality: 0 (reject)
 119                                                 value: 74
 120                                             }
 121                                             ResourceStatusFailure-IEs ::= {
 122                                                 id: 5
 123                                                 criticality: 1 (ignore)
 124                                                 value: 21 (unspecified)
 125                                             }
 126                                         }
 127                                     }
 128                                 }
 129                         */
 130                         packedPdu: "400900170000030027000300000000280003000049000540020a80",
 131                 },
 132         }
 133
 134         for _, tc := range testCases {
 135                 t.Run(tc.packedPdu, func(t *testing.T) {
 136                         var payload []byte
 137
 138                         _, err := fmt.Sscanf(tc.packedPdu, "%x", &payload)
 139                         if err != nil {
 140                                 t.Errorf("convert inputPayloadAsStr to payloadAsByte. Error: %v\n", err)
 141                         }
 142
 143                         response, err := rsFailureConverter.Convert(payload)
 144                         if err != nil {
 145                                 t.Errorf("want: success, got: unpack failed. Error: %v\n", err)
 146                         }
 147
 148                         got := response.String()
 149                         if len(tc.response) != len(got) {
 150                                 t.Errorf("\nwant :\t[%s]\n got: \t\t[%s]\n", tc.response, response)
 151                         }
 152                         if strings.Compare(tc.response, got) != 0 {
 153                                 t.Errorf("\nwant :\t[%s]\n got: \t\t[%s]\n", tc.response, got)
 154                         }
 155                 })
 156         }
 157 }
 158
 159 /*unpacking error*/
 160
 161 func TestResourceStatusFailureConverterError(t *testing.T) {
 162         logger, _ := logger.InitLogger(logger.InfoLevel)
 163         unpacker := NewX2apPduUnpacker(logger, e2pdus.MaxAsn1CodecMessageBufferSize)
 164         rsFailureConverter := NewResourceStatusFailureConverter(unpacker)
 165         wantError := "unpacking error: #src/asn1codec_utils.c.unpack_pdu_aux - Failed to decode E2AP-PDU (consumed 0), error = 0 Success"
 166         //--------------------2006002a
 167         inputPayloadAsStr := "2006002b000002001500080002f82900007a8000140017000000630002f8290007ab50102002f829000001000133"
 168         var payload []byte
 169         _, err := fmt.Sscanf(inputPayloadAsStr, "%x", &payload)
 170         if err != nil {
 171                 t.Errorf("convert inputPayloadAsStr to payloadAsByte. Error: %v\n", err)
 172         }
 173
 174         _, err = rsFailureConverter.Convert(payload)
 175         if err != nil {
 176                 if 0 != strings.Compare(fmt.Sprintf("%s", err), wantError) {
 177                         t.Errorf("want failure: %s, got: %s", wantError, err)
 178                 }
 179         } else {
 180                 t.Errorf("want failure: %s, got: success", wantError)
 181
 182         }
 183 }
 184
 185 func TestResourceStatusFailureConverterPduOfSuccess(t *testing.T) {
 186         logger, _ := logger.InitLogger(logger.InfoLevel)
 187         unpacker := NewX2apPduUnpacker(logger, e2pdus.MaxAsn1CodecMessageBufferSize)
 188         rsFailureConverter := NewResourceStatusFailureConverter(unpacker)
 189         wantError := "unexpected PDU, 2"
 190         inputPayloadAsStr := "200900220000030027000300000e0028000300000c0041400d00004240080002f8290007ab50"
 191         var payload []byte
 192         _, err := fmt.Sscanf(inputPayloadAsStr, "%x", &payload)
 193         if err != nil {
 194                 t.Errorf("convert inputPayloadAsStr to payloadAsByte. Error: %v\n", err)
 195         }
 196
 197         _, err = rsFailureConverter.Convert(payload)
 198         if err != nil {
 199                 if 0 != strings.Compare(fmt.Sprintf("%s", err), wantError) {
 200                         t.Errorf("want failure: %s, got: %s", wantError, err)
 201                 }
 202         } else {
 203                 t.Errorf("want failure: %s, got: success", wantError)
 204
 205         }
 206 }
 207
 208 func TestResourceStatusFailureConverterWrongPdu(t *testing.T) {
 209         logger, _ := logger.InitLogger(logger.InfoLevel)
 210         unpacker := NewX2apPduUnpacker(logger, e2pdus.MaxAsn1CodecMessageBufferSize)
 211         rsFailureConverter := NewResourceStatusFailureConverter(unpacker)
 212         wantError := "unexpected PDU - not a resource status failure"
 213         inputPayloadAsStr := "4006001a0000030005400200000016400100001140087821a00000008040"
 214         var payload []byte
 215         _, err := fmt.Sscanf(inputPayloadAsStr, "%x", &payload)
 216         if err != nil {
 217                 t.Errorf("convert inputPayloadAsStr to payloadAsByte. Error: %v\n", err)
 218         }
 219
 220         _, err = rsFailureConverter.Convert(payload)
 221         if err != nil {
 222                 if 0 != strings.Compare(fmt.Sprintf("%s", err), wantError) {
 223                         t.Errorf("want failure: %s, got: %s", wantError, err)
 224                 }
 225         } else {
 226                 t.Errorf("want failure: %s, got: success", wantError)
 227
 228         }
 229 }