RSM/services/resource_status_service_test.go

   1 //
   2 // Copyright 2019 AT&T Intellectual Property
   3 // Copyright 2019 Nokia
   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 package services
  19
  20 import (
  21         "fmt"
  22         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  23         "github.com/stretchr/testify/assert"
  24         "rsm/enums"
  25         "rsm/logger"
  26         "rsm/mocks"
  27         "rsm/models"
  28         "rsm/rmrcgo"
  29         "rsm/rsmerrors"
  30         "rsm/services/rmrsender"
  31         "rsm/tests"
  32         "testing"
  33 )
  34
  35 const RanName = "test"
  36 const NodebOneCellPackedExample = "0009003c00000800270003000000001c00010000260004fe000000001d400d00001f40080002f8290007ab00001e4001000040400100006d4001400091400120"
  37 const NodebTwoCellsPackedExample = "0009004800000800270003000000001c00010000260004fe000000001d401901001f40080002f8290007ab00001f40080002f8290007ab50001e4001000040400100006d4001400091400120"
  38 const StopPackedExample = "0009004f0000090027000300000000280003000001001c00014000260004fe000000001d401901001f40080002f8290007ab00001f40080002f8290007ab50001e4001000040400100006d4001400091400120"
  39
  40 func initResourceStatusServiceTest(t *testing.T) (*mocks.RmrMessengerMock, *models.RsmGeneralConfiguration, *ResourceStatusService) {
  41         logger, err := logger.InitLogger(logger.DebugLevel)
  42         if err != nil {
  43                 t.Errorf("#... - failed to initialize logger, error: %s", err)
  44         }
  45
  46         rmrMessengerMock := &mocks.RmrMessengerMock{}
  47         rmrSender := InitRmrSender(rmrMessengerMock, logger)
  48         resourceStatusService := NewResourceStatusService(logger, rmrSender)
  49
  50         rsmGeneralConfiguration := models.RsmGeneralConfiguration{
  51                 EnableResourceStatus:         true,
  52                 PartialSuccessAllowed:        true,
  53                 PrbPeriodic:                  true,
  54                 TnlLoadIndPeriodic:           true,
  55                 HwLoadIndPeriodic:            true,
  56                 AbsStatusPeriodic:            true,
  57                 RsrpMeasurementPeriodic:      true,
  58                 CsiPeriodic:                  true,
  59                 PeriodicityMs:                enums.ReportingPeriodicity_one_thousand_ms,
  60                 PeriodicityRsrpMeasurementMs: enums.ReportingPeriodicityRSRPMR_four_hundred_80_ms,
  61                 PeriodicityCsiMs:             enums.ReportingPeriodicityCSIR_ms20,
  62         }
  63
  64         return rmrMessengerMock, &rsmGeneralConfiguration, resourceStatusService
  65 }
  66
  67 func TestOneCellSuccess(t *testing.T) {
  68         cellId := "02f829:0007ab00"
  69         rmrMessengerMock, rsmGeneralConfiguration, resourceStatusService := initResourceStatusServiceTest(t)
  70
  71         xaction := []byte(RanName)
  72         nodebInfo := &entities.NodebInfo{
  73                 RanName:          RanName,
  74                 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
  75                 Configuration: &entities.NodebInfo_Enb{
  76                         Enb: &entities.Enb{
  77                                 ServedCells: []*entities.ServedCellInfo{{CellId: cellId}},
  78                         },
  79                 },
  80         }
  81
  82         var expectedPayload []byte
  83         _, _ = fmt.Sscanf(NodebOneCellPackedExample, "%x", &expectedPayload)
  84         var err error
  85         expectedMbuf := rmrcgo.NewMBuf(rmrcgo.RicResStatusReq, len(expectedPayload), RanName, &expectedPayload, &xaction)
  86         rmrMessengerMock.On("SendMsg", expectedMbuf).Return(&rmrcgo.MBuf{}, err)
  87         err = resourceStatusService.BuildAndSendInitiateRequest(nodebInfo, rsmGeneralConfiguration, enums.Enb1MeasurementId)
  88         assert.Nil(t, err)
  89         rmrMessengerMock.AssertCalled(t, "SendMsg", expectedMbuf)
  90 }
  91
  92 func TestTwoCellsSuccess(t *testing.T) {
  93         cellId1 := "02f829:0007ab00"
  94         cellId2 := "02f829:0007ab50"
  95         rmrMessengerMock, rsmGeneralConfiguration, resourceStatusService := initResourceStatusServiceTest(t)
  96         xaction := []byte(RanName)
  97         nodebInfo := &entities.NodebInfo{
  98                 RanName:          RanName,
  99                 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
 100                 Configuration: &entities.NodebInfo_Enb{
 101                         Enb: &entities.Enb{
 102                                 ServedCells: []*entities.ServedCellInfo{{CellId: cellId1}, {CellId: cellId2}},
 103                         },
 104                 },
 105         }
 106
 107         var expectedPayload []byte
 108         _, _ = fmt.Sscanf(NodebTwoCellsPackedExample, "%x", &expectedPayload)
 109         expectedMbuf := rmrcgo.NewMBuf(rmrcgo.RicResStatusReq, len(expectedPayload), RanName, &expectedPayload, &xaction)
 110         var err error
 111         rmrMessengerMock.On("SendMsg", expectedMbuf).Return(&rmrcgo.MBuf{}, err)
 112         err = resourceStatusService.BuildAndSendInitiateRequest(nodebInfo, rsmGeneralConfiguration, enums.Enb1MeasurementId)
 113         assert.Nil(t, err)
 114         rmrMessengerMock.AssertCalled(t, "SendMsg", expectedMbuf)
 115 }
 116
 117 func TestOneCellSendFailure(t *testing.T) {
 118         cellId := "02f829:0007ab00"
 119         rmrMessengerMock, rsmGeneralConfiguration, resourceStatusService := initResourceStatusServiceTest(t)
 120
 121         xaction := []byte(RanName)
 122         var err error
 123         nodebInfo := &entities.NodebInfo{
 124                 RanName:          RanName,
 125                 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
 126                 Configuration: &entities.NodebInfo_Enb{
 127                         Enb: &entities.Enb{
 128                                 ServedCells: []*entities.ServedCellInfo{{CellId: cellId}},
 129                         },
 130                 },
 131         }
 132
 133         var expectedPayload []byte
 134         _, _ = fmt.Sscanf(NodebOneCellPackedExample, "%x", &expectedPayload)
 135         expectedMbuf := rmrcgo.NewMBuf(rmrcgo.RicResStatusReq, len(expectedPayload), RanName, &expectedPayload, &xaction)
 136         rmrMessengerMock.On("SendMsg", expectedMbuf).Return(&rmrcgo.MBuf{}, rsmerrors.NewRmrError())
 137         err = resourceStatusService.BuildAndSendInitiateRequest(nodebInfo, rsmGeneralConfiguration, 1)
 138         assert.NotNil(t, err)
 139         rmrMessengerMock.AssertCalled(t, "SendMsg", expectedMbuf)
 140 }
 141
 142
 143
 144 func TestNodebConfigurationFailure(t *testing.T) {
 145         rmrMessengerMock, rsmGeneralConfiguration, resourceStatusService := initResourceStatusServiceTest(t)
 146         nodebInfo := &entities.NodebInfo{
 147                 RanName:          RanName,
 148                 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
 149         }
 150
 151         err := resourceStatusService.BuildAndSendInitiateRequest(nodebInfo, rsmGeneralConfiguration, enums.Enb1MeasurementId)
 152         assert.NotNil(t, err)
 153         rmrMessengerMock.AssertNotCalled(t, "SendMsg")
 154 }
 155
 156 func TestNodebEmptyCellList(t *testing.T) {
 157         rmrMessengerMock, rsmGeneralConfiguration, resourceStatusService := initResourceStatusServiceTest(t)
 158         nodebInfo := &entities.NodebInfo{
 159                 RanName:          RanName,
 160                 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
 161                 Configuration: &entities.NodebInfo_Enb{
 162                         Enb: &entities.Enb{
 163                                 ServedCells: []*entities.ServedCellInfo{},
 164                         },
 165                 },
 166         }
 167
 168         err := resourceStatusService.BuildAndSendInitiateRequest(nodebInfo, rsmGeneralConfiguration, enums.Enb1MeasurementId)
 169         assert.NotNil(t, err)
 170         rmrMessengerMock.AssertNotCalled(t, "SendMsg")
 171 }
 172
 173 func TestPackFailure(t *testing.T) {
 174         rmrMessengerMock, rsmGeneralConfiguration, resourceStatusService := initResourceStatusServiceTest(t)
 175         nodebInfo := &entities.NodebInfo{
 176                 RanName:          RanName,
 177                 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
 178                 Configuration: &entities.NodebInfo_Enb{
 179                         Enb: &entities.Enb{
 180                                 ServedCells: []*entities.ServedCellInfo{{CellId: ""}},
 181                         },
 182                 },
 183         }
 184
 185         err := resourceStatusService.BuildAndSendInitiateRequest(nodebInfo, rsmGeneralConfiguration, enums.Enb1MeasurementId)
 186         assert.NotNil(t, err)
 187         rmrMessengerMock.AssertNotCalled(t, "SendMsg")
 188 }
 189
 190 func TestBuildAndSendStopRequestSuccess(t *testing.T) {
 191         rmrMessengerMock, rsmGeneralConfiguration, resourceStatusService := initResourceStatusServiceTest(t)
 192
 193         cellId1 := "02f829:0007ab00"
 194         cellId2 := "02f829:0007ab50"
 195         nodebInfo := &entities.NodebInfo{
 196                 RanName:          RanName,
 197                 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
 198                 Configuration: &entities.NodebInfo_Enb{
 199                         Enb: &entities.Enb{
 200                                 ServedCells: []*entities.ServedCellInfo{{CellId: cellId1}, {CellId: cellId2}},
 201                         },
 202                 },
 203         }
 204         xaction := []byte(RanName)
 205         var expectedPayload []byte
 206         _, _ = fmt.Sscanf(StopPackedExample, "%x", &expectedPayload)
 207         expectedMbuf := rmrcgo.NewMBuf(rmrcgo.RicResStatusReq, len(expectedPayload), RanName, &expectedPayload, &xaction)
 208         var err error
 209         rmrMessengerMock.On("SendMsg", expectedMbuf).Return(&rmrcgo.MBuf{}, err)
 210         err = resourceStatusService.BuildAndSendStopRequest(nodebInfo, rsmGeneralConfiguration, enums.Enb1MeasurementId, 2)
 211         assert.Nil(t, err)
 212         rmrMessengerMock.AssertCalled(t, "SendMsg", expectedMbuf)
 213 }
 214
 215 func TestBuildAndSendStopRequestSendFailure(t *testing.T) {
 216         rmrMessengerMock, rsmGeneralConfiguration, resourceStatusService := initResourceStatusServiceTest(t)
 217
 218         xaction := []byte(RanName)
 219         cellId1 := "02f829:0007ab00"
 220         cellId2 := "02f829:0007ab50"
 221         nodebInfo := &entities.NodebInfo{
 222                 RanName:          RanName,
 223                 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
 224                 Configuration: &entities.NodebInfo_Enb{
 225                         Enb: &entities.Enb{
 226                                 ServedCells: []*entities.ServedCellInfo{{CellId: cellId1}, {CellId: cellId2}},
 227                         },
 228                 },
 229         }
 230
 231         var err error
 232         var expectedPayload []byte
 233         _, _ = fmt.Sscanf(StopPackedExample, "%x", &expectedPayload)
 234         expectedMbuf := rmrcgo.NewMBuf(rmrcgo.RicResStatusReq, len(expectedPayload), RanName, &expectedPayload, &xaction)
 235         rmrMessengerMock.On("SendMsg", expectedMbuf).Return(&rmrcgo.MBuf{}, rsmerrors.NewRmrError())
 236         err = resourceStatusService.BuildAndSendStopRequest(nodebInfo, rsmGeneralConfiguration, enums.Enb1MeasurementId, 2)
 237
 238         assert.NotNil(t, err)
 239         rmrMessengerMock.AssertCalled(t, "SendMsg", expectedMbuf)
 240 }
 241
 242 func InitRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
 243         rmrMessenger := rmrcgo.RmrMessenger(rmrMessengerMock)
 244         rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
 245         return rmrsender.NewRmrSender(log, rmrMessenger)
 246 }