E2Manager/handlers/rmrmsghandlers/e2_setup_request_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         "bytes"
  24         "e2mgr/configuration"
  25         "e2mgr/managers"
  26         "e2mgr/mocks"
  27         "e2mgr/models"
  28         "e2mgr/rmrCgo"
  29         "e2mgr/services"
  30         "e2mgr/tests"
  31         "encoding/xml"
  32         "errors"
  33         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  34         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  35         "github.com/stretchr/testify/assert"
  36         "github.com/stretchr/testify/mock"
  37         "io/ioutil"
  38         "path/filepath"
  39         "testing"
  40 )
  41
  42 const (
  43         e2tInstanceFullAddress                   = "10.0.2.15:9999"
  44         e2SetupMsgPrefix                         = e2tInstanceFullAddress + "|"
  45         gnbNodebRanName                          = "gnb:310-410-b5c67788"
  46         enbNodebRanName                          = "enB_macro:P310-410-b5c67788"
  47         GnbSetupRequestXmlPath                   = "../../tests/resources/setupRequest_gnb.xml"
  48         EnGnbSetupRequestXmlPath                 = "../../tests/resources/setupRequest_en-gNB.xml"
  49         NgEnbSetupRequestXmlPath                 = "../../tests/resources/setupRequest_ng-eNB.xml"
  50         EnbSetupRequestXmlPath                   = "../../tests/resources/setupRequest_enb.xml"
  51         GnbWithoutFunctionsSetupRequestXmlPath   = "../../tests/resources/setupRequest_gnb_without_functions.xml"
  52         E2SetupFailureResponseWithMiscCause      = "<E2AP-PDU><unsuccessfulOutcome><procedureCode>1</procedureCode><criticality><reject/></criticality><value><E2setupFailure><protocolIEs><E2setupFailureIEs><id>1</id><criticality><ignore/></criticality><value><Cause><misc><om-intervention/></misc></Cause></value></E2setupFailureIEs><E2setupFailureIEs><id>31</id><criticality><ignore/></criticality><value><TimeToWait><v60s/></TimeToWait></value></E2setupFailureIEs></protocolIEs></E2setupFailure></value></unsuccessfulOutcome></E2AP-PDU>"
  53         E2SetupFailureResponseWithTransportCause = "<E2AP-PDU><unsuccessfulOutcome><procedureCode>1</procedureCode><criticality><reject/></criticality><value><E2setupFailure><protocolIEs><E2setupFailureIEs><id>1</id><criticality><ignore/></criticality><value><Cause><transport><transport-resource-unavailable/></transport></Cause></value></E2setupFailureIEs><E2setupFailureIEs><id>31</id><criticality><ignore/></criticality><value><TimeToWait><v60s/></TimeToWait></value></E2setupFailureIEs></protocolIEs></E2setupFailure></value></unsuccessfulOutcome></E2AP-PDU>"
  54         E2SetupFailureResponseWithRicCause       = "<E2AP-PDU><unsuccessfulOutcome><procedureCode>1</procedureCode><criticality><reject/></criticality><value><E2setupFailure><protocolIEs><E2setupFailureIEs><id>1</id><criticality><ignore/></criticality><value><Cause><ricRequest><request-id-unknown/></ricRequest></Cause></value></E2setupFailureIEs><E2setupFailureIEs><id>31</id><criticality><ignore/></criticality><value><TimeToWait><v60s/></TimeToWait></value></E2setupFailureIEs></protocolIEs></E2setupFailure></value></unsuccessfulOutcome></E2AP-PDU>"
  55         StateChangeMessageChannel                = "RAN_CONNECTION_STATUS_CHANGE"
  56 )
  57
  58 func readXmlFile(t *testing.T, xmlPath string) []byte {
  59         path, err := filepath.Abs(xmlPath)
  60         if err != nil {
  61                 t.Fatal(err)
  62         }
  63         xmlAsBytes, err := ioutil.ReadFile(path)
  64         if err != nil {
  65                 t.Fatal(err)
  66         }
  67
  68         return xmlAsBytes
  69 }
  70
  71 func TestParseGnbSetupRequest_Success(t *testing.T) {
  72         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
  73         handler, _, _, _, _, _ := initMocks(t)
  74         prefBytes := []byte(e2SetupMsgPrefix)
  75         request, _, err := handler.parseSetupRequest(append(prefBytes, xmlGnb...))
  76         assert.Equal(t, "02F829", request.GetPlmnId())
  77         assert.Equal(t, "001100000011000000110000", request.GetNbId())
  78         assert.Nil(t, err)
  79 }
  80
  81 func TestParseEnGnbSetupRequest_Success(t *testing.T) {
  82         enGnbXml := readXmlFile(t, EnGnbSetupRequestXmlPath)
  83         handler, _, _, _, _, _ := initMocks(t)
  84         prefBytes := []byte(e2SetupMsgPrefix)
  85         request, _, err := handler.parseSetupRequest(append(prefBytes, enGnbXml...))
  86         assert.Equal(t, "131014", request.GetPlmnId())
  87         assert.Equal(t, "11000101110001101100011111111000", request.GetNbId())
  88         assert.Nil(t, err)
  89 }
  90
  91 func TestParseNgEnbSetupRequest_Success(t *testing.T) {
  92         ngEnbXml := readXmlFile(t, NgEnbSetupRequestXmlPath)
  93         handler, _, _, _, _, _ := initMocks(t)
  94         prefBytes := []byte(e2SetupMsgPrefix)
  95         request, _, err := handler.parseSetupRequest(append(prefBytes, ngEnbXml...))
  96         assert.Equal(t, "131014", request.GetPlmnId())
  97         assert.Equal(t, "101010101010101010", request.GetNbId())
  98         assert.Nil(t, err)
  99 }
 100
 101 func TestParseEnbSetupRequest_Success(t *testing.T) {
 102         enbXml := readXmlFile(t, EnbSetupRequestXmlPath)
 103         handler, _, _, _, _, _ := initMocks(t)
 104         prefBytes := []byte(e2SetupMsgPrefix)
 105         request, _, err := handler.parseSetupRequest(append(prefBytes, enbXml...))
 106         assert.Equal(t, "6359AB", request.GetPlmnId())
 107         assert.Equal(t, "101010101010101010", request.GetNbId())
 108         assert.Nil(t, err)
 109 }
 110
 111 func TestParseSetupRequest_PipFailure(t *testing.T) {
 112         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 113         handler, _, _, _, _, _ := initMocks(t)
 114         prefBytes := []byte("10.0.2.15:9999")
 115         request, _, err := handler.parseSetupRequest(append(prefBytes, xmlGnb...))
 116         assert.Nil(t, request)
 117         assert.NotNil(t, err)
 118         assert.EqualError(t, err, "#E2SetupRequestNotificationHandler.parseSetupRequest - Error parsing E2 Setup Request failed extract Payload: no | separator found")
 119 }
 120
 121 func TestParseSetupRequest_UnmarshalFailure(t *testing.T) {
 122         handler, _, _, _, _, _ := initMocks(t)
 123         prefBytes := []byte(e2SetupMsgPrefix)
 124         request, _, err := handler.parseSetupRequest(append(prefBytes, 1, 2, 3))
 125         assert.Nil(t, request)
 126         assert.NotNil(t, err)
 127         assert.EqualError(t, err, "#E2SetupRequestNotificationHandler.parseSetupRequest - Error unmarshalling E2 Setup Request payload: 31302e302e322e31353a393939397c010203")
 128 }
 129
 130 func TestE2SetupRequestNotificationHandler_GetGeneralConfigurationFailure(t *testing.T) {
 131         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 132         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 133         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{}, common.NewInternalError(errors.New("some error")))
 134         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 135         handler.Handle(notificationRequest)
 136         rmrMessengerMock.AssertNotCalled(t, "SendMsg")
 137         e2tInstancesManagerMock.AssertNotCalled(t, "GetE2TInstance")
 138         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance")
 139         readerMock.AssertNotCalled(t, "GetNodeb")
 140         writerMock.AssertNotCalled(t, "SaveNodeb")
 141 }
 142
 143 func getMbuf(ranName string, msgType int, payloadStr string, request *models.NotificationRequest) *rmrCgo.MBuf {
 144         payload := []byte(payloadStr)
 145         mbuf := rmrCgo.NewMBuf(msgType, len(payload), ranName, &payload, &request.TransactionId, request.GetMsgSrc())
 146         return mbuf
 147 }
 148
 149 func TestE2SetupRequestNotificationHandler_EnableRicFalse(t *testing.T) {
 150         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 151         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 152         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: false}, nil)
 153         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 154         mbuf := getMbuf(gnbNodebRanName, rmrCgo.RIC_E2_SETUP_FAILURE, E2SetupFailureResponseWithMiscCause, notificationRequest)
 155         rmrMessengerMock.On("WhSendMsg", mbuf, true).Return(&rmrCgo.MBuf{}, nil)
 156         handler.Handle(notificationRequest)
 157         rmrMessengerMock.AssertCalled(t, "WhSendMsg", mbuf, true)
 158         e2tInstancesManagerMock.AssertNotCalled(t, "GetE2TInstance")
 159         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance")
 160         readerMock.AssertNotCalled(t, "GetNodeb")
 161         writerMock.AssertNotCalled(t, "SaveNodeb")
 162 }
 163
 164 func TestE2SetupRequestNotificationHandler_HandleNewRanSaveNodebFailure(t *testing.T) {
 165         xml := readXmlFile(t, GnbSetupRequestXmlPath)
 166         handler, readerMock, writerMock, _, e2tInstancesManagerMock, _ := initMocks(t)
 167         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 168         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 169         var gnb *entities.NodebInfo
 170         readerMock.On("GetNodeb", gnbNodebRanName).Return(gnb, common.NewResourceNotFoundError("Not found"))
 171         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xml...)}
 172         nodebInfo := getExpectedGnbNodebForNewRan(notificationRequest.Payload)
 173         writerMock.On("SaveNodeb", nodebInfo).Return(common.NewInternalError(errors.New("error")))
 174         handler.Handle(notificationRequest)
 175
 176         readerMock.AssertExpectations(t)
 177         writerMock.AssertExpectations(t)
 178         e2tInstancesManagerMock.AssertExpectations(t)
 179 }
 180
 181 func TestE2SetupRequestNotificationHandler_HandleNewRan_invalidRanName(t *testing.T) {
 182         xml := readXmlFile(t, EnbSetupRequestXmlPath)
 183         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initMocks(t)
 184         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 185         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 186         var enb *entities.NodebInfo
 187         invalidEnbRanName := "enB-macro:P310-410-b5c67788"
 188         readerMock.On("GetNodeb", invalidEnbRanName).Return(enb, common.NewResourceNotFoundError("Not found"))
 189         notificationRequest := &models.NotificationRequest{RanName: invalidEnbRanName, Payload: append([]byte(e2SetupMsgPrefix), xml...)}
 190         mbuf := getMbuf(invalidEnbRanName, rmrCgo.RIC_E2_SETUP_FAILURE, E2SetupFailureResponseWithRicCause, notificationRequest)
 191         rmrMessengerMock.On("WhSendMsg", mbuf, true).Return(&rmrCgo.MBuf{}, nil)
 192         handler.Handle(notificationRequest)
 193
 194         readerMock.AssertExpectations(t)
 195         writerMock.AssertExpectations(t)
 196         rmrMessengerMock.AssertCalled(t, "WhSendMsg", mbuf, true)
 197         e2tInstancesManagerMock.AssertExpectations(t)
 198 }
 199
 200 func TestE2SetupRequestNotificationHandler_HandleNewRanAddNbIdentityFailure(t *testing.T) {
 201         xml := readXmlFile(t, GnbSetupRequestXmlPath)
 202         handler, readerMock, writerMock, _, e2tInstancesManagerMock, _ := initMocks(t)
 203         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 204         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 205         var gnb *entities.NodebInfo
 206         readerMock.On("GetNodeb", gnbNodebRanName).Return(gnb, common.NewResourceNotFoundError("Not found"))
 207         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xml...)}
 208         nodebInfo := getExpectedGnbNodebForNewRan(notificationRequest.Payload)
 209         writerMock.On("SaveNodeb", nodebInfo).Return(nil)
 210         nbIdentity := &entities.NbIdentity{InventoryName: gnbNodebRanName, GlobalNbId: nodebInfo.GlobalNbId}
 211         writerMock.On("AddNbIdentity", entities.Node_GNB, nbIdentity).Return(common.NewInternalError(errors.New("error")))
 212         handler.Handle(notificationRequest)
 213         readerMock.AssertExpectations(t)
 214         writerMock.AssertExpectations(t)
 215         e2tInstancesManagerMock.AssertExpectations(t)
 216 }
 217
 218 func testE2SetupRequestNotificationHandler_HandleNewRanSuccess(t *testing.T, xmlPath string, nodeType entities.Node_Type) {
 219         xml := readXmlFile(t, xmlPath)
 220         var ranName string
 221         if nodeType == entities.Node_GNB {
 222                 ranName = gnbNodebRanName
 223         } else {
 224                 ranName = enbNodebRanName
 225         }
 226         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 227         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 228         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 229         var gnb *entities.NodebInfo
 230         readerMock.On("GetNodeb", ranName).Return(gnb, common.NewResourceNotFoundError("Not found"))
 231         notificationRequest := &models.NotificationRequest{RanName: ranName, Payload: append([]byte(e2SetupMsgPrefix), xml...)}
 232         var expectedNodebInfo *entities.NodebInfo
 233         if nodeType == entities.Node_GNB {
 234                 expectedNodebInfo = getExpectedGnbNodebForNewRan(notificationRequest.Payload)
 235         } else {
 236                 expectedNodebInfo = getExpectedEnbNodebForNewRan(notificationRequest.Payload)
 237         }
 238         writerMock.On("SaveNodeb", expectedNodebInfo).Return(nil)
 239         nbIdentity := &entities.NbIdentity{InventoryName: ranName, GlobalNbId: expectedNodebInfo.GlobalNbId}
 240         writerMock.On("AddNbIdentity", nodeType, nbIdentity).Return(nil)
 241         updatedNodebInfo := *expectedNodebInfo
 242         updatedNodebInfo.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 243         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &updatedNodebInfo, ranName+"_CONNECTED").Return(nil)
 244         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 245         updatedNodebInfo2 := *expectedNodebInfo
 246         updatedNodebInfo2.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 247         updatedNodebInfo2.AssociatedE2TInstanceAddress = e2tInstanceFullAddress
 248         writerMock.On("UpdateNodebInfo", &updatedNodebInfo2).Return(nil)
 249         e2tInstancesManagerMock.On("AddRansToInstance", e2tInstanceFullAddress, []string{ranName}).Return(nil)
 250         rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(&rmrCgo.MBuf{}, nil)
 251
 252         handler.Handle(notificationRequest)
 253
 254         readerMock.AssertExpectations(t)
 255         writerMock.AssertExpectations(t)
 256         e2tInstancesManagerMock.AssertExpectations(t)
 257 }
 258
 259 func TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess(t *testing.T) {
 260         testE2SetupRequestNotificationHandler_HandleNewRanSuccess(t, GnbSetupRequestXmlPath, entities.Node_GNB)
 261 }
 262
 263 func TestE2SetupRequestNotificationHandler_HandleNewGnbWithoutFunctionsSuccess(t *testing.T) {
 264         testE2SetupRequestNotificationHandler_HandleNewRanSuccess(t, GnbWithoutFunctionsSetupRequestXmlPath, entities.Node_GNB)
 265 }
 266
 267 func TestE2SetupRequestNotificationHandler_HandleNewEnGnbSuccess(t *testing.T) {
 268         testE2SetupRequestNotificationHandler_HandleNewRanSuccess(t, EnGnbSetupRequestXmlPath, entities.Node_GNB)
 269 }
 270
 271 func TestE2SetupRequestNotificationHandler_HandleNewNgEnbSuccess(t *testing.T) {
 272         testE2SetupRequestNotificationHandler_HandleNewRanSuccess(t, NgEnbSetupRequestXmlPath, entities.Node_ENB)
 273 }
 274
 275 func TestExtractionOfNodeTypeFromRanName(t *testing.T) {
 276         handler, _, _, _, _, _ := initMocks(t)
 277         validRanNames := []string{"gnb_P310_410_b5c67788", "en_gnb_P310_410_b5c67788", "ng_enB_macro_P310_410_b5c67788", "ng_enB_shortmacro_P310_410_b5c67788", "ng_enB_longmacro_P310_410_b5c67788", "enB_macro_P310_410_b5c67788", "enB_home_P310_410_b5c67788", "enB_shortmacro_P310_410_b5c67788", "enB_longmacro_P310_410_b5c67788"}
 278         for _, v := range validRanNames {
 279                 nodeb := &entities.NodebInfo{RanName: v}
 280                 err := handler.setNodeTypeAndConfiguration(nodeb)
 281                 assert.Nil(t, err)
 282         }
 283         inValidRanNames := []string{"P310_410_b5c67788", "blabla_P310_410_b5c67788", "ng_enB-macro_P310_410_b5c67788", "ng_enb_shortmacro_P310_410_b5c67788", "ng_enB-longmacro_P310_410_b5c67788", "enB_new_macro_P310_410_b5c67788"}
 284         for _, v := range inValidRanNames {
 285                 nodeb := &entities.NodebInfo{RanName: v}
 286                 err := handler.setNodeTypeAndConfiguration(nodeb)
 287                 assert.NotNil(t, err, v)
 288         }
 289 }
 290
 291 func testE2SetupRequestNotificationHandler_HandleExistingConnectedGnbSuccess(t *testing.T, withFunctions bool) {
 292         var xmlGnb []byte
 293
 294         if withFunctions {
 295                 xmlGnb = readXmlFile(t, GnbSetupRequestXmlPath)
 296
 297         } else {
 298                 xmlGnb = readXmlFile(t, GnbWithoutFunctionsSetupRequestXmlPath)
 299         }
 300         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 301         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 302         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 303         var nodebInfo = &entities.NodebInfo{
 304                 RanName:                      gnbNodebRanName,
 305                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 306                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 307                 NodeType:                     entities.Node_GNB,
 308                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
 309         }
 310
 311         if withFunctions {
 312                 gnb := nodebInfo.GetGnb()
 313                 gnb.RanFunctions = []*entities.RanFunction{{RanFunctionId: 2, RanFunctionRevision: 2}}
 314         }
 315
 316         readerMock.On("GetNodeb", gnbNodebRanName).Return(nodebInfo, nil)
 317         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 318
 319         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 320         gnbToUpdate := getExpectedNodebForExistingRan(*nodebInfo, notificationRequest.Payload)
 321
 322         writerMock.On("UpdateNodebInfo", gnbToUpdate).Return(nil)
 323         if withFunctions {
 324                 writerMock.On("UpdateNodebInfoAndPublish", gnbToUpdate).Return(nil)
 325         }
 326         e2tInstancesManagerMock.On("AddRansToInstance", e2tInstanceFullAddress, []string{gnbNodebRanName}).Return(nil)
 327         var errEmpty error
 328         rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(&rmrCgo.MBuf{}, errEmpty)
 329         handler.Handle(notificationRequest)
 330         readerMock.AssertExpectations(t)
 331         writerMock.AssertExpectations(t)
 332         e2tInstancesManagerMock.AssertExpectations(t)
 333         rmrMessengerMock.AssertCalled(t, "SendMsg", mock.Anything, true)
 334 }
 335
 336 func TestE2SetupRequestNotificationHandler_HandleExistingConnectedGnbWithoutFunctionsSuccess(t *testing.T) {
 337         testE2SetupRequestNotificationHandler_HandleExistingConnectedGnbSuccess(t, false)
 338 }
 339
 340 func TestE2SetupRequestNotificationHandler_HandleExistingConnectedGnbWithFunctionsSuccess(t *testing.T) {
 341         testE2SetupRequestNotificationHandler_HandleExistingConnectedGnbSuccess(t, true)
 342 }
 343
 344 func TestE2SetupRequestNotificationHandler_HandleExistingDisconnectedGnbSuccess(t *testing.T) {
 345         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 346         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 347         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 348         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 349         var nodebInfo = &entities.NodebInfo{
 350                 RanName:                      gnbNodebRanName,
 351                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 352                 ConnectionStatus:             entities.ConnectionStatus_DISCONNECTED,
 353                 NodeType:                     entities.Node_GNB,
 354                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
 355         }
 356
 357         readerMock.On("GetNodeb", gnbNodebRanName).Return(nodebInfo, nil)
 358         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 359
 360         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 361         gnbToUpdate := getExpectedNodebForExistingRan(*nodebInfo, notificationRequest.Payload)
 362         gnbToUpdate2 := *gnbToUpdate
 363         gnbToUpdate2.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 364         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &gnbToUpdate2, gnbNodebRanName+"_CONNECTED").Return(nil)
 365         gnbToUpdate3 := *gnbToUpdate
 366         gnbToUpdate3.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 367         gnbToUpdate3.AssociatedE2TInstanceAddress = e2tInstanceFullAddress
 368         writerMock.On("UpdateNodebInfo", &gnbToUpdate3).Return(nil)
 369         e2tInstancesManagerMock.On("AddRansToInstance", e2tInstanceFullAddress, []string{gnbNodebRanName}).Return(nil)
 370         var errEmpty error
 371         rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(&rmrCgo.MBuf{}, errEmpty)
 372         handler.Handle(notificationRequest)
 373         readerMock.AssertExpectations(t)
 374         writerMock.AssertExpectations(t)
 375         e2tInstancesManagerMock.AssertExpectations(t)
 376 }
 377
 378 func getExpectedNodebForExistingRan(nodeb entities.NodebInfo, payload []byte) *entities.NodebInfo {
 379         pipInd := bytes.IndexByte(payload, '|')
 380         setupRequest := &models.E2SetupRequestMessage{}
 381         _ = xml.Unmarshal(normalizeXml(payload[pipInd+1:]), &setupRequest.E2APPDU)
 382         if ranFuncs := setupRequest.ExtractRanFunctionsList(); ranFuncs != nil {
 383                 nodeb.GetGnb().RanFunctions = ranFuncs
 384         }
 385         return &nodeb
 386 }
 387
 388 func getExpectedGnbNodebForNewRan(payload []byte) *entities.NodebInfo {
 389         pipInd := bytes.IndexByte(payload, '|')
 390         setupRequest := &models.E2SetupRequestMessage{}
 391         _ = xml.Unmarshal(normalizeXml(payload[pipInd+1:]), &setupRequest.E2APPDU)
 392
 393         nodeb := &entities.NodebInfo{
 394                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 395                 RanName:                      gnbNodebRanName,
 396                 SetupFromNetwork:             true,
 397                 NodeType:                     entities.Node_GNB,
 398                 Configuration: &entities.NodebInfo_Gnb{
 399                         Gnb: &entities.Gnb{
 400                                 GnbType:      entities.GnbType_GNB,
 401                                 RanFunctions: setupRequest.ExtractRanFunctionsList(),
 402                         },
 403                 },
 404                 GlobalNbId: &entities.GlobalNbId{
 405                         PlmnId: setupRequest.GetPlmnId(),
 406                         NbId:   setupRequest.GetNbId(),
 407                 },
 408         }
 409
 410         return nodeb
 411 }
 412
 413 func getExpectedEnbNodebForNewRan(payload []byte) *entities.NodebInfo {
 414         pipInd := bytes.IndexByte(payload, '|')
 415         setupRequest := &models.E2SetupRequestMessage{}
 416         _ = xml.Unmarshal(normalizeXml(payload[pipInd+1:]), &setupRequest.E2APPDU)
 417
 418         nodeb := &entities.NodebInfo{
 419                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 420                 RanName:                      enbNodebRanName,
 421                 SetupFromNetwork:             true,
 422                 NodeType:                     entities.Node_ENB,
 423                 Configuration: &entities.NodebInfo_Enb{
 424                         Enb: &entities.Enb{
 425                                 EnbType: entities.EnbType_MACRO_ENB,
 426                         },
 427                 },
 428                 GlobalNbId: &entities.GlobalNbId{
 429                         PlmnId: setupRequest.GetPlmnId(),
 430                         NbId:   setupRequest.GetNbId(),
 431                 },
 432         }
 433
 434         return nodeb
 435 }
 436
 437 func TestE2SetupRequestNotificationHandler_HandleParseError(t *testing.T) {
 438         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 439         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 440         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 441         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte("invalid_prefix"), xmlGnb...)}
 442         handler.Handle(notificationRequest)
 443         readerMock.AssertNotCalled(t, "GetNodeb", mock.Anything)
 444         writerMock.AssertNotCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
 445         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 446         writerMock.AssertNotCalled(t, "UpdateNodebInfo", mock.Anything)
 447         e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
 448         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 449 }
 450
 451 func TestE2SetupRequestNotificationHandler_HandleUnmarshalError(t *testing.T) {
 452         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 453         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 454         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), "xmlGnb"...)}
 455         handler.Handle(notificationRequest)
 456         readerMock.AssertNotCalled(t, "GetNodeb", mock.Anything)
 457         writerMock.AssertNotCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
 458         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 459         writerMock.AssertNotCalled(t, "UpdateNodebInfo", mock.Anything)
 460         e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
 461         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 462 }
 463
 464 func TestE2SetupRequestNotificationHandler_HandleGetE2TInstanceError(t *testing.T) {
 465         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 466         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 467         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 468         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, common.NewResourceNotFoundError("Not found"))
 469         prefBytes := []byte(e2SetupMsgPrefix)
 470         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append(prefBytes, xmlGnb...)}
 471         handler.Handle(notificationRequest)
 472         e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceFullAddress)
 473         readerMock.AssertNotCalled(t, "GetNodeb", mock.Anything)
 474         writerMock.AssertNotCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
 475         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 476         writerMock.AssertNotCalled(t, "UpdateNodebInfo", mock.Anything)
 477         e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
 478         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 479 }
 480
 481 func TestE2SetupRequestNotificationHandler_HandleGetNodebError(t *testing.T) {
 482         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 483         handler, readerMock, writerMock, routingManagerClientMock, e2tInstancesManagerMock, rmrMessengerMock := initMocks(t)
 484         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 485         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 486         var gnb *entities.NodebInfo
 487         readerMock.On("GetNodeb", mock.Anything).Return(gnb, common.NewInternalError(errors.New("some error")))
 488         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 489         handler.Handle(notificationRequest)
 490         e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceFullAddress)
 491         readerMock.AssertCalled(t, "GetNodeb", mock.Anything)
 492         writerMock.AssertNotCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
 493         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 494         writerMock.AssertNotCalled(t, "UpdateNodebInfo", mock.Anything)
 495         e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
 496         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 497 }
 498
 499 func TestE2SetupRequestNotificationHandler_HandleAssociationError(t *testing.T) {
 500         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 501
 502         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 503         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 504         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 505         var gnb *entities.NodebInfo
 506         readerMock.On("GetNodeb", mock.Anything).Return(gnb, common.NewResourceNotFoundError("Not found"))
 507         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 508         nodebInfo := getExpectedGnbNodebForNewRan(notificationRequest.Payload)
 509         writerMock.On("SaveNodeb", nodebInfo).Return(nil)
 510         nbIdentity := &entities.NbIdentity{InventoryName: gnbNodebRanName, GlobalNbId: nodebInfo.GlobalNbId}
 511         writerMock.On("AddNbIdentity", entities.Node_GNB, nbIdentity).Return(nil)
 512         updatedNodebInfo := *nodebInfo
 513         updatedNodebInfo.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 514         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &updatedNodebInfo, gnbNodebRanName+"_CONNECTED").Return(nil)
 515         writerMock.On("UpdateNodebInfo", mock.Anything).Return(nil)
 516         e2tInstancesManagerMock.On("AddRansToInstance", mock.Anything, mock.Anything).Return(nil)
 517         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(errors.New("association error"))
 518         updatedNodebInfo2 := *nodebInfo
 519         updatedNodebInfo2.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
 520         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &updatedNodebInfo2, gnbNodebRanName+"_DISCONNECTED").Return(nil)
 521         var errEmpty error
 522         mbuf := getMbuf(gnbNodebRanName, rmrCgo.RIC_E2_SETUP_FAILURE, E2SetupFailureResponseWithTransportCause, notificationRequest)
 523         rmrMessengerMock.On("WhSendMsg", mbuf, true).Return(&rmrCgo.MBuf{}, errEmpty)
 524         handler.Handle(notificationRequest)
 525         readerMock.AssertCalled(t, "GetNodeb", mock.Anything)
 526         e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceFullAddress)
 527         writerMock.AssertCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
 528         routingManagerClientMock.AssertCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 529         e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
 530         rmrMessengerMock.AssertCalled(t, "WhSendMsg", mbuf, true)
 531 }
 532
 533 func TestE2SetupRequestNotificationHandler_ConvertTo20BitStringError(t *testing.T) {
 534         xmlEnGnb := readXmlFile(t, EnGnbSetupRequestXmlPath)
 535         logger := tests.InitLog(t)
 536         config := &configuration.Configuration{
 537                 RnibRetryIntervalMs:       10,
 538                 MaxRnibConnectionAttempts: 3,
 539                 RnibWriter: configuration.RnibWriterConfig{
 540                         StateChangeMessageChannel: StateChangeMessageChannel,
 541                 },
 542                 GlobalRicId: struct {
 543                         RicId string
 544                         Mcc   string
 545                         Mnc   string
 546                 }{Mcc: "327", Mnc: "94", RicId: "10011001101010101011"}}
 547         rmrMessengerMock := &mocks.RmrMessengerMock{}
 548         rmrSender := tests.InitRmrSender(rmrMessengerMock, logger)
 549         readerMock := &mocks.RnibReaderMock{}
 550         writerMock := &mocks.RnibWriterMock{}
 551         routingManagerClientMock := &mocks.RoutingManagerClientMock{}
 552         rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
 553         e2tInstancesManagerMock := &mocks.E2TInstancesManagerMock{}
 554         ranListManager := managers.NewRanListManager(logger, rnibDataService)
 555         ranAlarmService := services.NewRanAlarmService(logger, config)
 556         ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService, ranListManager, ranAlarmService)
 557
 558         e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManagerMock, routingManagerClientMock, ranConnectStatusChangeManager)
 559         handler := NewE2SetupRequestNotificationHandler(logger, config, e2tInstancesManagerMock, rmrSender, rnibDataService, e2tAssociationManager, ranConnectStatusChangeManager, ranListManager)
 560         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 561         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 562         var gnb *entities.NodebInfo
 563         readerMock.On("GetNodeb", mock.Anything).Return(gnb, common.NewResourceNotFoundError("Not found"))
 564         writerMock.On("SaveNodeb", mock.Anything, mock.Anything).Return(nil)
 565         writerMock.On("AddNbIdentity", entities.Node_GNB, mock.Anything).Return(nil)
 566         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", mock.Anything, mock.Anything).Return(nil)
 567         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 568         writerMock.On("UpdateNodebInfo", mock.Anything).Return(nil)
 569         e2tInstancesManagerMock.On("AddRansToInstance", mock.Anything, mock.Anything).Return(nil)
 570         var errEmpty error
 571         rmrMessage := &rmrCgo.MBuf{}
 572         rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(rmrMessage, errEmpty)
 573         prefBytes := []byte(e2SetupMsgPrefix)
 574         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append(prefBytes, xmlEnGnb...)}
 575         handler.Handle(notificationRequest)
 576         readerMock.AssertCalled(t, "GetNodeb", mock.Anything)
 577         e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceFullAddress)
 578         writerMock.AssertCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
 579         routingManagerClientMock.AssertCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 580         writerMock.AssertCalled(t, "UpdateNodebInfo", mock.Anything)
 581         e2tInstancesManagerMock.AssertCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
 582         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 583 }
 584
 585 func TestE2SetupRequestNotificationHandler_HandleExistingGnbInvalidStatusError(t *testing.T) {
 586         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 587         handler, readerMock, writerMock, routingManagerClientMock, e2tInstancesManagerMock, rmrMessengerMock := initMocks(t)
 588         var gnb = &entities.NodebInfo{RanName: gnbNodebRanName, ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 589         readerMock.On("GetNodeb", mock.Anything).Return(gnb, nil)
 590         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 591         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 592         prefBytes := []byte(e2SetupMsgPrefix)
 593         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append(prefBytes, xmlGnb...)}
 594         handler.Handle(notificationRequest)
 595         readerMock.AssertCalled(t, "GetNodeb", mock.Anything)
 596         e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceFullAddress)
 597         writerMock.AssertNotCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
 598         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 599         writerMock.AssertNotCalled(t, "UpdateNodebInfo", mock.Anything)
 600         e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
 601         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 602 }
 603
 604 func initMocks(t *testing.T) (*E2SetupRequestNotificationHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock, *mocks.RoutingManagerClientMock) {
 605         logger := tests.InitLog(t)
 606         config := &configuration.Configuration{
 607                 RnibRetryIntervalMs:       10,
 608                 MaxRnibConnectionAttempts: 3,
 609                 RnibWriter: configuration.RnibWriterConfig{
 610                         StateChangeMessageChannel: StateChangeMessageChannel,
 611                 },
 612                 GlobalRicId: struct {
 613                         RicId string
 614                         Mcc   string
 615                         Mnc   string
 616                 }{Mcc: "327", Mnc: "94", RicId: "AACCE"}}
 617         rmrMessengerMock := &mocks.RmrMessengerMock{}
 618         rmrSender := tests.InitRmrSender(rmrMessengerMock, logger)
 619         readerMock := &mocks.RnibReaderMock{}
 620         writerMock := &mocks.RnibWriterMock{}
 621         routingManagerClientMock := &mocks.RoutingManagerClientMock{}
 622         rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
 623         e2tInstancesManagerMock := &mocks.E2TInstancesManagerMock{}
 624         ranListManager := managers.NewRanListManager(logger, rnibDataService)
 625         ranAlarmService := services.NewRanAlarmService(logger, config)
 626         ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService, ranListManager, ranAlarmService)
 627         e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManagerMock, routingManagerClientMock, ranConnectStatusChangeManager)
 628         handler := NewE2SetupRequestNotificationHandler(logger, config, e2tInstancesManagerMock, rmrSender, rnibDataService, e2tAssociationManager, ranConnectStatusChangeManager, ranListManager)
 629         return handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock
 630 }