RSM/handlers/rmrmsghandlers/resource_status_initiate_notification_handler_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 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
  18 //  platform project (RICP).
  19
  20 package rmrmsghandlers
  21
  22 import (
  23         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  24         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  25         "github.com/pkg/errors"
  26         "github.com/stretchr/testify/assert"
  27         "github.com/stretchr/testify/mock"
  28         "rsm/configuration"
  29         "rsm/enums"
  30         "rsm/logger"
  31         "rsm/mocks"
  32         "rsm/models"
  33         "rsm/services"
  34         "rsm/tests"
  35         "testing"
  36         "time"
  37 )
  38
  39 const RanName = "test"
  40
  41
  42 func initRanConnectedNotificationHandlerTest(t *testing.T, requestName string) (ResourceStatusInitiateNotificationHandler, *mocks.RnibReaderMock, *mocks.ResourceStatusServiceMock, *mocks.RsmWriterMock, *mocks.RsmReaderMock) {
  43         log, err := logger.InitLogger(logger.DebugLevel)
  44         if err != nil {
  45                 t.Errorf("#... - failed to initialize logger, error: %s", err)
  46         }
  47
  48         config, err := configuration.ParseConfiguration()
  49         if err != nil {
  50                 t.Errorf("#... - failed to parse configuration error: %s", err)
  51         }
  52
  53         resourceStatusServiceMock := &mocks.ResourceStatusServiceMock{}
  54         rnibReaderMock := &mocks.RnibReaderMock{}
  55         rsmReaderMock := &mocks.RsmReaderMock{}
  56         rsmWriterMock := &mocks.RsmWriterMock{}
  57
  58         rnibDataService := services.NewRnibDataService(log, config, rnibReaderMock, rsmReaderMock, rsmWriterMock)
  59
  60         h := NewResourceStatusInitiateNotificationHandler(log, rnibDataService, resourceStatusServiceMock, requestName)
  61         return h, rnibReaderMock, resourceStatusServiceMock, rsmWriterMock, rsmReaderMock
  62 }
  63
  64 func TestHandlerInit(t *testing.T) {
  65         h, _, _, _, _ := initRanConnectedNotificationHandlerTest(t, "RanConnected")
  66         assert.NotNil(t, h)
  67 }
  68
  69 func TestJsonUnmarshalError(t *testing.T) {
  70         h, rnibReaderMock, resourceStatusServiceMock, _, _ := initRanConnectedNotificationHandlerTest(t, "RanConnected")
  71
  72         payloadStr := "blabla"
  73         payload := []byte(payloadStr)
  74         rmrReq := &models.RmrRequest{RanName: RanName, Payload: payload, Len: len(payload), StartTime: time.Now()}
  75
  76         rnibReaderMock.On("GetNodeb", RanName).Return(mock.AnythingOfType("*entities.NodebInfo"))
  77         resourceStatusServiceMock.On("BuildAndSendInitiateRequest", mock.AnythingOfType("*entities.NodebInfo"), mock.AnythingOfType("*models.RsmGeneralConfiguration"), enums.Enb1MeasurementId).Return(nil)
  78         h.Handle(rmrReq)
  79         rnibReaderMock.AssertNumberOfCalls(t, "GetNodeb", 0)
  80         resourceStatusServiceMock.AssertNumberOfCalls(t, "BuildAndSendInitiateRequest", 0)
  81 }
  82
  83 func TestUnknownJsonValue(t *testing.T) {
  84         h, rnibReaderMock, resourceStatusServiceMock, _, _ := initRanConnectedNotificationHandlerTest(t, "RanConnected")
  85
  86         payloadStr := "{\"whatever\":3}"
  87         payload := []byte(payloadStr)
  88         rmrReq := &models.RmrRequest{RanName: RanName, Payload: payload, Len: len(payload), StartTime: time.Now()}
  89
  90         rnibReaderMock.On("GetNodeb", RanName).Return(mock.AnythingOfType("*entities.NodebInfo"))
  91         resourceStatusServiceMock.On("BuildAndSendInitiateRequest", mock.AnythingOfType("*entities.NodebInfo"), mock.AnythingOfType("*models.RsmGeneralConfiguration"), enums.Enb1MeasurementId).Return(nil)
  92         h.Handle(rmrReq)
  93         rnibReaderMock.AssertNumberOfCalls(t, "GetNodeb", 0)
  94         resourceStatusServiceMock.AssertNumberOfCalls(t, "BuildAndSendInitiateRequest", 0)
  95 }
  96
  97 func TestHandleGnbNode(t *testing.T) {
  98         h, rnibReaderMock, resourceStatusServiceMock, _, _ := initRanConnectedNotificationHandlerTest(t, "RanConnected")
  99
 100         payloadStr := "{\"nodeType\":2, \"messageDirection\":1}"
 101         payload := []byte(payloadStr)
 102         rmrReq := &models.RmrRequest{RanName: "RAN1", Payload: payload, Len: len(payload), StartTime: time.Now()}
 103         rnibReaderMock.On("GetNodeb", RanName).Return(mock.AnythingOfType("*entities.NodebInfo"))
 104         resourceStatusServiceMock.On("BuildAndSendInitiateRequest", mock.AnythingOfType("*entities.NodebInfo"), mock.AnythingOfType("*models.RsmGeneralConfiguration"), enums.Enb1MeasurementId).Return(nil)
 105         h.Handle(rmrReq)
 106         rnibReaderMock.AssertNumberOfCalls(t, "GetNodeb", 0)
 107         resourceStatusServiceMock.AssertNumberOfCalls(t, "BuildAndSendInitiateRequest", 0)
 108 }
 109
 110 func TestGetRsmGeneralConfigurationFailure(t *testing.T) {
 111         h, _, resourceStatusServiceMock, _, rsmReaderMock := initRanConnectedNotificationHandlerTest(t, "RanConnected")
 112         var rgc models.RsmGeneralConfiguration
 113         rsmReaderMock.On("GetRsmGeneralConfiguration").Return(&rgc, common.NewInternalError(errors.New("Error")))
 114         payloadStr := "{\"nodeType\":1, \"messageDirection\":1}"
 115         payload := []byte(payloadStr)
 116         rmrReq := &models.RmrRequest{RanName: RanName, Payload: payload, Len: len(payload), StartTime: time.Now()}
 117         resourceStatusServiceMock.On("BuildAndSendInitiateRequest", mock.AnythingOfType("*entities.NodebInfo"), mock.AnythingOfType("*models.RsmGeneralConfiguration"), enums.Enb1MeasurementId).Return(nil)
 118         h.Handle(rmrReq)
 119         rsmReaderMock.AssertCalled(t, "GetRsmGeneralConfiguration")
 120         resourceStatusServiceMock.AssertNumberOfCalls(t, "BuildAndSendInitiateRequest", 0)
 121 }
 122
 123 func TestEnableResourceStatusFalse(t *testing.T) {
 124         h, _, resourceStatusServiceMock, rsmWriterMock, rsmReaderMock := initRanConnectedNotificationHandlerTest(t, "RanConnected")
 125         var err error
 126         rsmReaderMock.On("GetRsmGeneralConfiguration").Return(tests.GetRsmGeneralConfiguration(false), err)
 127         rsmRanInfo := models.RsmRanInfo{RanName, 0, 0, enums.Stop, true}
 128         rsmWriterMock.On("SaveRsmRanInfo", &rsmRanInfo).Return(err)
 129
 130         payloadStr := "{\"nodeType\":1, \"messageDirection\":1}"
 131         payload := []byte(payloadStr)
 132         rmrReq := &models.RmrRequest{RanName: RanName, Payload: payload, Len: len(payload), StartTime: time.Now()}
 133         resourceStatusServiceMock.On("BuildAndSendInitiateRequest", mock.AnythingOfType("*entities.NodebInfo"), mock.AnythingOfType("*models.RsmGeneralConfiguration"), enums.Enb1MeasurementId).Return(nil)
 134         h.Handle(rmrReq)
 135         rsmReaderMock.AssertCalled(t, "GetRsmGeneralConfiguration")
 136         rsmWriterMock.AssertNumberOfCalls(t, "SaveRsmRanInfo", 1)
 137         resourceStatusServiceMock.AssertNumberOfCalls(t, "BuildAndSendInitiateRequest", 0)
 138 }
 139
 140 func TestEnableResourceStatusFalseSaveRsmRanInfoFailure(t *testing.T) {
 141         h, _, resourceStatusServiceMock, rsmWriterMock, rsmReaderMock := initRanConnectedNotificationHandlerTest(t, "RanConnected")
 142         var err error
 143         rsmReaderMock.On("GetRsmGeneralConfiguration").Return(tests.GetRsmGeneralConfiguration(false), err)
 144         rsmRanInfo := models.RsmRanInfo{RanName, 0, 0, enums.Stop, true}
 145         rsmWriterMock.On("SaveRsmRanInfo", &rsmRanInfo).Return(common.NewInternalError(errors.New("Error")))
 146
 147         payloadStr := "{\"nodeType\":1, \"messageDirection\":1}"
 148         payload := []byte(payloadStr)
 149         rmrReq := &models.RmrRequest{RanName: RanName, Payload: payload, Len: len(payload), StartTime: time.Now()}
 150         resourceStatusServiceMock.On("BuildAndSendInitiateRequest", mock.AnythingOfType("*entities.NodebInfo"), mock.AnythingOfType("*models.RsmGeneralConfiguration"), enums.Enb1MeasurementId).Return(nil)
 151         h.Handle(rmrReq)
 152         rsmReaderMock.AssertCalled(t, "GetRsmGeneralConfiguration")
 153         rsmWriterMock.AssertNumberOfCalls(t, "SaveRsmRanInfo", 1)
 154         resourceStatusServiceMock.AssertNumberOfCalls(t, "BuildAndSendInitiateRequest", 0)
 155 }
 156
 157 func TestGetNodebFailure(t *testing.T) {
 158         h, rnibReaderMock, resourceStatusServiceMock, _, rsmReaderMock := initRanConnectedNotificationHandlerTest(t, "RanConnected")
 159
 160         payloadStr := "{\"nodeType\":1, \"messageDirection\":1}"
 161         payload := []byte(payloadStr)
 162         rmrReq := &models.RmrRequest{RanName: RanName, Payload: payload, Len: len(payload), StartTime: time.Now()}
 163
 164         var err error
 165         rsmReaderMock.On("GetRsmGeneralConfiguration").Return(tests.GetRsmGeneralConfiguration(true), err)
 166
 167         var nodebInfo *entities.NodebInfo
 168         rnibReaderMock.On("GetNodeb", RanName).Return(nodebInfo, common.NewInternalError(errors.New("Error")))
 169         resourceStatusServiceMock.On("BuildAndSendInitiateRequest", mock.AnythingOfType("*entities.NodebInfo"), mock.AnythingOfType("*models.RsmGeneralConfiguration"), enums.Enb1MeasurementId).Return(nil)
 170         h.Handle(rmrReq)
 171         rsmReaderMock.AssertCalled(t, "GetRsmGeneralConfiguration")
 172         rnibReaderMock.AssertCalled(t, "GetNodeb", RanName)
 173         resourceStatusServiceMock.AssertNumberOfCalls(t, "BuildAndSendInitiateRequest", 0)
 174 }
 175
 176 func TestInvalidConnectionStatus(t *testing.T) {
 177         h, rnibReaderMock, resourceStatusServiceMock, rsmWriterMock, rsmReaderMock := initRanConnectedNotificationHandlerTest(t, "RanConnected")
 178         var err error
 179         rsmReaderMock.On("GetRsmGeneralConfiguration").Return(tests.GetRsmGeneralConfiguration(true), err)
 180         rnibReaderMock.On("GetNodeb", RanName).Return(&entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED}, err)
 181         rsmRanInfo := models.RsmRanInfo{RanName, 0, 0, enums.Stop, true}
 182         rsmWriterMock.On("SaveRsmRanInfo", &rsmRanInfo).Return(err)
 183
 184         payloadStr := "{\"nodeType\":1, \"messageDirection\":1}"
 185         payload := []byte(payloadStr)
 186         rmrReq := &models.RmrRequest{RanName: RanName, Payload: payload, Len: len(payload), StartTime: time.Now()}
 187         resourceStatusServiceMock.On("BuildAndSendInitiateRequest", mock.AnythingOfType("*entities.NodebInfo"), mock.AnythingOfType("*models.RsmGeneralConfiguration"), enums.Enb1MeasurementId).Return(nil)
 188         h.Handle(rmrReq)
 189         rsmReaderMock.AssertCalled(t, "GetRsmGeneralConfiguration")
 190         rnibReaderMock.AssertCalled(t, "GetNodeb", RanName)
 191         rsmWriterMock.AssertNumberOfCalls(t, "SaveRsmRanInfo", 1)
 192         resourceStatusServiceMock.AssertNumberOfCalls(t, "BuildAndSendInitiateRequest", 0)
 193 }
 194
 195 func TestEnableResourceStatusTrueSaveRsmRanInfoFailure(t *testing.T) {
 196         h, rnibReaderMock, resourceStatusServiceMock, rsmWriterMock, rsmReaderMock := initRanConnectedNotificationHandlerTest(t, "RanConnected")
 197
 198         payloadStr := "{\"nodeType\":1, \"messageDirection\":1}"
 199         payload := []byte(payloadStr)
 200         rmrReq := &models.RmrRequest{RanName: RanName, Payload: payload, Len: len(payload), StartTime: time.Now()}
 201
 202         var err error
 203         rsmReaderMock.On("GetRsmGeneralConfiguration").Return(tests.GetRsmGeneralConfiguration(true), err)
 204         rnibReaderMock.On("GetNodeb", RanName).Return(&entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}, err)
 205         rsmRanInfo := models.RsmRanInfo{RanName, enums.Enb1MeasurementId, 0, enums.Start, false}
 206         rsmWriterMock.On("SaveRsmRanInfo", &rsmRanInfo).Return(common.NewInternalError(errors.New("Error")))
 207         resourceStatusServiceMock.On("BuildAndSendInitiateRequest", mock.AnythingOfType("*entities.NodebInfo"), mock.AnythingOfType("*models.RsmGeneralConfiguration"), enums.Enb1MeasurementId).Return(nil)
 208         h.Handle(rmrReq)
 209         rsmReaderMock.AssertCalled(t, "GetRsmGeneralConfiguration")
 210         rnibReaderMock.AssertCalled(t, "GetNodeb", RanName)
 211         rsmWriterMock.AssertNumberOfCalls(t, "SaveRsmRanInfo", 1)
 212         resourceStatusServiceMock.AssertNumberOfCalls(t, "BuildAndSendInitiateRequest", 0)
 213 }
 214
 215 func TestBuildAndSendSuccess(t *testing.T) {
 216         h, rnibReaderMock, resourceStatusServiceMock, rsmWriterMock, rsmReaderMock := initRanConnectedNotificationHandlerTest(t, "RanConnected")
 217
 218         payloadStr := "{\"nodeType\":1, \"messageDirection\":1}"
 219         payload := []byte(payloadStr)
 220         rmrReq := &models.RmrRequest{RanName: RanName, Payload: payload, Len: len(payload), StartTime: time.Now()}
 221
 222         var err error
 223         rgc := tests.GetRsmGeneralConfiguration(true)
 224         rsmReaderMock.On("GetRsmGeneralConfiguration").Return(rgc, err)
 225         nodebInfo := &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
 226         rnibReaderMock.On("GetNodeb", RanName).Return(nodebInfo, err)
 227         rsmRanInfo := models.RsmRanInfo{RanName, enums.Enb1MeasurementId, 0, enums.Start, false}
 228         rsmWriterMock.On("SaveRsmRanInfo", &rsmRanInfo).Return(err)
 229
 230         resourceStatusServiceMock.On("BuildAndSendInitiateRequest", nodebInfo, rgc, enums.Enb1MeasurementId).Return(nil)
 231         h.Handle(rmrReq)
 232         rnibReaderMock.AssertCalled(t, "GetNodeb", RanName)
 233         rsmReaderMock.AssertCalled(t, "GetRsmGeneralConfiguration")
 234         rsmWriterMock.AssertNumberOfCalls(t, "SaveRsmRanInfo", 1)
 235         resourceStatusServiceMock.AssertNumberOfCalls(t, "BuildAndSendInitiateRequest", 1)
 236 }
 237
 238 func TestBuildAndSendError(t *testing.T) {
 239         h, rnibReaderMock, resourceStatusServiceMock, rsmWriterMock, rsmReaderMock := initRanConnectedNotificationHandlerTest(t, "RanConnected")
 240         var err error
 241         nodebInfo := &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
 242         rgc := tests.GetRsmGeneralConfiguration(true)
 243         rsmReaderMock.On("GetRsmGeneralConfiguration").Return(rgc, err)
 244         rnibReaderMock.On("GetNodeb", RanName).Return(nodebInfo, err)
 245         rsmRanInfoStart := models.RsmRanInfo{RanName, enums.Enb1MeasurementId, 0, enums.Start, false}
 246         rsmWriterMock.On("SaveRsmRanInfo", &rsmRanInfoStart).Return(err)
 247         rsmRanInfoStop := models.RsmRanInfo{RanName, 0, 0, enums.Stop, true}
 248         rsmWriterMock.On("SaveRsmRanInfo", &rsmRanInfoStop).Return(err)
 249         payloadStr := "{\"nodeType\":1, \"messageDirection\":1}"
 250         payload := []byte(payloadStr)
 251         rmrReq := &models.RmrRequest{RanName: RanName, Payload: payload, Len: len(payload), StartTime: time.Now()}
 252         resourceStatusServiceMock.On("BuildAndSendInitiateRequest", nodebInfo, rgc, enums.Enb1MeasurementId).Return(common.NewInternalError(errors.New("Error")))
 253         h.Handle(rmrReq)
 254         rsmReaderMock.AssertCalled(t, "GetRsmGeneralConfiguration")
 255         rnibReaderMock.AssertCalled(t, "GetNodeb", RanName)
 256         resourceStatusServiceMock.AssertNumberOfCalls(t, "BuildAndSendInitiateRequest", 1)
 257         rsmWriterMock.AssertNumberOfCalls(t, "SaveRsmRanInfo", 2)
 258 }