RSM/converters/resource_status_response_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 TestResourceStatusResponseConverter(t *testing.T) {
  40         logger, _ := logger.InitLogger(logger.DebugLevel)
  41         unpacker := NewX2apPduUnpacker(logger, e2pdus.MaxAsn1CodecMessageBufferSize)
  42         rsConverters := NewResourceStatusResponseConverter(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: [  ]  ]",
  50                         /*
  51                                 SuccessfulOutcome ::= {
  52                                         procedureCode: 9
  53                                         criticality: 0 (reject)
  54                                         value: ResourceStatusResponse ::= {
  55                                                 protocolIEs: ProtocolIE-Container ::= {
  56                                                         ResourceStatusResponse-IEs ::= {
  57                                                                 id: 39
  58                                                                 criticality: 0 (reject)
  59                                                                 value: 15
  60                                                         }
  61                                                         ResourceStatusResponse-IEs ::= {
  62                                                                 id: 40
  63                                                                 criticality: 0 (reject)
  64                                                                 value: 13
  65                                                         }
  66                                                         ResourceStatusResponse-IEs ::= {
  67                                                                 id: 65
  68                                                                 criticality: 1 (ignore)
  69                                                                 value: MeasurementInitiationResult-List ::= {
  70                                                                         ProtocolIE-Single-Container ::= {
  71                                                                                 id: 66
  72                                                                                 criticality: 1 (ignore)
  73                                                                                 value: MeasurementInitiationResult-Item ::= {
  74                                                                                         cell-ID: ECGI ::= {
  75                                                                                                 pLMN-Identity: 02 F8 29
  76                                                                                                 eUTRANcellIdentifier: 00 07 AB 50 (4 bits unused)
  77                                                                                         }
  78                                                                                 }
  79                                                                         }
  80                                                                 }
  81                                                         }
  82                                                 }
  83                                         }
  84                                 }
  85                         */
  86
  87                         packedPdu: "200900220000030027000300000e0028000300000c0041400d00004240080002f8290007ab50",
  88                 },
  89                 {response: "ENB1_Measurement_ID: 1, ENB2_Measurement_ID: 75, MeasurementInitiationResults:[ CellId: 133023:02b030a0, MeasurementFailureCauses: [ MeasurementFailedReportCharacteristics: 02000000 MeasurementFailedReportCharacteristics: 04000000 MeasurementFailedReportCharacteristics: 08000000 MeasurementFailedReportCharacteristics: 20000000 MeasurementFailedReportCharacteristics: 40000000 MeasurementFailedReportCharacteristics: 80000000  ]  ]",
  90                         /*
  91                                  SuccessfulOutcome ::= {
  92                                     procedureCode: 9
  93                                     criticality: 0 (reject)
  94                                     value: ResourceStatusResponse ::= {
  95                                         protocolIEs: ProtocolIE-Container ::= {
  96                                             ResourceStatusResponse-IEs ::= {
  97                                                 id: 39
  98                                                 criticality: 0 (reject)
  99                                                 value: 1
 100                                             }
 101                                             ResourceStatusResponse-IEs ::= {
 102                                                 id: 40
 103                                                 criticality: 0 (reject)
 104                                                 value: 75
 105                                             }
 106                                             ResourceStatusResponse-IEs ::= {
 107                                                 id: 65
 108                                                 criticality: 1 (ignore)
 109                                                 value: MeasurementInitiationResult-List ::= {
 110                                                     ProtocolIE-Single-Container ::= {
 111                                                         id: 66
 112                                                         criticality: 1 (ignore)
 113                                                         value: MeasurementInitiationResult-Item ::= {
 114                                                             cell-ID: ECGI ::= {
 115                                                                 pLMN-Identity: 13 30 23
 116                                                                 eUTRANcellIdentifier: 02 B0 30 A0 (4 bits unused)
 117                                                             }
 118                                                             measurementFailureCause-List: MeasurementFailureCause-List ::= {
 119                                                                 ProtocolIE-Single-Container ::= {
 120                                                                     id: 67
 121                                                                     criticality: 1 (ignore)
 122                                                                     value: MeasurementFailureCause-Item ::= {
 123                                                                         measurementFailedReportCharacteristics: 02 00 00 00
 124                                                                         cause: 20 (measurement-temporarily-not-available)
 125                                                                     }
 126                                                                 }
 127                                                                 ProtocolIE-Single-Container ::= {
 128                                                                     id: 67
 129                                                                     criticality: 1 (ignore)
 130                                                                     value: MeasurementFailureCause-Item ::= {
 131                                                                         measurementFailedReportCharacteristics: 04 00 00 00
 132                                                                         cause: 20 (measurement-temporarily-not-available)
 133                                                                     }
 134                                                                 }
 135                                                                 ProtocolIE-Single-Container ::= {
 136                                                                     id: 67
 137                                                                     criticality: 1 (ignore)
 138                                                                     value: MeasurementFailureCause-Item ::= {
 139                                                                         measurementFailedReportCharacteristics: 08 00 00 00
 140                                                                         cause: 20 (measurement-temporarily-not-available)
 141                                                                     }
 142                                                                 }
 143                                                                 ProtocolIE-Single-Container ::= {
 144                                                                     id: 67
 145                                                                     criticality: 1 (ignore)
 146                                                                     value: MeasurementFailureCause-Item ::= {
 147                                                                         measurementFailedReportCharacteristics: 20 00 00 00
 148                                                                         cause: 20 (measurement-temporarily-not-available)
 149                                                                     }
 150                                                                 }
 151                                                                 ProtocolIE-Single-Container ::= {
 152                                                                     id: 67
 153                                                                     criticality: 1 (ignore)
 154                                                                     value: MeasurementFailureCause-Item ::= {
 155                                                                         measurementFailedReportCharacteristics: 40 00 00 00
 156                                                                         cause: 20 (measurement-temporarily-not-available)
 157                                                                     }
 158                                                                 }
 159                                                                 ProtocolIE-Single-Container ::= {
 160                                                                     id: 67
 161                                                                     criticality: 1 (ignore)
 162                                                                     value: MeasurementFailureCause-Item ::= {
 163                                                                         measurementFailedReportCharacteristics: 80 00 00 00
 164                                                                         cause: 20 (measurement-temporarily-not-available)
 165                                                                     }
 166                                                                 }
 167                                                             }
 168                                                         }
 169                                                     }
 170                                                 }
 171                                             }
 172                                         }
 173                                     }
 174                                 }
 175                         */
 176                         packedPdu: "20090065000003002700030000000028000300004a00414050000042404b4013302302b030a2800043400700020000000a000043400700040000000a000043400700080000000a000043400700200000000a000043400700400000000a000043400700800000000a00"},
 177         }
 178
 179         for _, tc := range testCases {
 180                 t.Run(tc.packedPdu, func(t *testing.T) {
 181                         var payload []byte
 182
 183                         _, err := fmt.Sscanf(tc.packedPdu, "%x", &payload)
 184                         if err != nil {
 185                                 t.Errorf("convert inputPayloadAsStr to payloadAsByte. Error: %v\n", err)
 186                         }
 187
 188                         response, err := rsConverters.Convert(payload)
 189                         if err != nil {
 190                                 t.Errorf("want: success, got: unpack failed. Error: %v\n", err)
 191                         }
 192
 193                         got := response.String()
 194                         if len(tc.response) != len(got) {
 195                                 t.Errorf("\nwant :\t[%s]\n got: \t\t[%s]\n", tc.response, response)
 196                         }
 197                         if strings.Compare(tc.response, got) != 0 {
 198                                 t.Errorf("\nwant :\t[%s]\n got: \t\t[%s]\n", tc.response, got)
 199                         }
 200                 })
 201         }
 202 }
 203
 204 /*unpacking error*/
 205
 206 func TestResourceStatusResponseConverterError(t *testing.T) {
 207         logger, _ := logger.InitLogger(logger.InfoLevel)
 208         unpacker := NewX2apPduUnpacker(logger, e2pdus.MaxAsn1CodecMessageBufferSize)
 209         rsConverters := NewResourceStatusResponseConverter(unpacker)
 210
 211         wantError := "unpacking error: #src/asn1codec_utils.c.unpack_pdu_aux - Failed to decode E2AP-PDU (consumed 0), error = 0 Success"
 212         //--------------------2006002a
 213         inputPayloadAsStr := "2006002b000002001500080002f82900007a8000140017000000630002f8290007ab50102002f829000001000133"
 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 = rsConverters.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 }
 230
 231 func TestResourceStatusResponseConverterPduOfFailure(t *testing.T) {
 232         logger, _ := logger.InitLogger(logger.InfoLevel)
 233         unpacker := NewX2apPduUnpacker(logger, e2pdus.MaxAsn1CodecMessageBufferSize)
 234         rsConverters := NewResourceStatusResponseConverter(unpacker)
 235
 236         wantError := "unexpected PDU, 3"
 237         inputPayloadAsStr := "400900170000030027000300000000280003000049000540020a80"
 238         var payload []byte
 239         _, err := fmt.Sscanf(inputPayloadAsStr, "%x", &payload)
 240         if err != nil {
 241                 t.Errorf("convert inputPayloadAsStr to payloadAsByte. Error: %v\n", err)
 242         }
 243
 244         _, err = rsConverters.Convert(payload)
 245         if err != nil {
 246                 if 0 != strings.Compare(fmt.Sprintf("%s", err), wantError) {
 247                         t.Errorf("want failure: %s, got: %s", wantError, err)
 248                 }
 249         } else {
 250                 t.Errorf("want failure: %s, got: success", wantError)
 251
 252         }
 253 }
 254
 255 func TestResourceStatusResponseConverterWrongPdu(t *testing.T) {
 256         logger, _ := logger.InitLogger(logger.InfoLevel)
 257         unpacker := NewX2apPduUnpacker(logger, e2pdus.MaxAsn1CodecMessageBufferSize)
 258         rsConverters := NewResourceStatusResponseConverter(unpacker)
 259
 260         wantError := "unexpected PDU - not a resource status response"
 261         inputPayloadAsStr := "2006002a000002001500080002f82900007a8000140017000000630002f8290007ab50102002f829000001000133"
 262         var payload []byte
 263         _, err := fmt.Sscanf(inputPayloadAsStr, "%x", &payload)
 264         if err != nil {
 265                 t.Errorf("convert inputPayloadAsStr to payloadAsByte. Error: %v\n", err)
 266         }
 267
 268         _, err = rsConverters.Convert(payload)
 269         if err != nil {
 270                 if 0 != strings.Compare(fmt.Sprintf("%s", err), wantError) {
 271                         t.Errorf("want failure: %s, got: %s", wantError, err)
 272                 }
 273         } else {
 274                 t.Errorf("want failure: %s, got: success", wantError)
 275
 276         }
 277 }