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 initMocks(t *testing.T) (*E2SetupRequestNotificationHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock, *mocks.RoutingManagerClientMock) {
  59         logger := tests.InitLog(t)
  60         config := &configuration.Configuration{
  61                 RnibRetryIntervalMs:       10,
  62                 MaxRnibConnectionAttempts: 3,
  63                 RnibWriter: configuration.RnibWriterConfig{
  64                         StateChangeMessageChannel: StateChangeMessageChannel,
  65                 },
  66                 GlobalRicId: struct {
  67                         RicId string
  68                         Mcc   string
  69                         Mnc   string
  70                 }{Mcc: "327", Mnc: "94", RicId: "AACCE"}}
  71         rmrMessengerMock := &mocks.RmrMessengerMock{}
  72         rmrSender := tests.InitRmrSender(rmrMessengerMock, logger)
  73         readerMock := &mocks.RnibReaderMock{}
  74         writerMock := &mocks.RnibWriterMock{}
  75         routingManagerClientMock := &mocks.RoutingManagerClientMock{}
  76         rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
  77         e2tInstancesManagerMock := &mocks.E2TInstancesManagerMock{}
  78         ranListManager := managers.NewRanListManager(logger, rnibDataService)
  79         ranAlarmService := services.NewRanAlarmService(logger, config)
  80         ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService, ranListManager, ranAlarmService)
  81         e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManagerMock, routingManagerClientMock, ranConnectStatusChangeManager)
  82         handler := NewE2SetupRequestNotificationHandler(logger, config, e2tInstancesManagerMock, rmrSender, rnibDataService, e2tAssociationManager, ranConnectStatusChangeManager, ranListManager)
  83         return handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock
  84 }
  85
  86 func getMbuf(ranName string, msgType int, payloadStr string, request *models.NotificationRequest) *rmrCgo.MBuf {
  87         payload := []byte(payloadStr)
  88         mbuf := rmrCgo.NewMBuf(msgType, len(payload), ranName, &payload, &request.TransactionId, request.GetMsgSrc())
  89         return mbuf
  90 }
  91
  92 func readXmlFile(t *testing.T, xmlPath string) []byte {
  93         path, err := filepath.Abs(xmlPath)
  94         if err != nil {
  95                 t.Fatal(err)
  96         }
  97         xmlAsBytes, err := ioutil.ReadFile(path)
  98         if err != nil {
  99                 t.Fatal(err)
 100         }
 101
 102         return xmlAsBytes
 103 }
 104
 105 func TestParseGnbSetupRequest_Success(t *testing.T) {
 106         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 107         handler, _, _, _, _, _ := initMocks(t)
 108         prefBytes := []byte(e2SetupMsgPrefix)
 109         request, _, err := handler.parseSetupRequest(append(prefBytes, xmlGnb...))
 110         assert.Equal(t, "02F829", request.GetPlmnId())
 111         assert.Equal(t, "001100000011000000110000", request.GetNbId())
 112         assert.Nil(t, err)
 113 }
 114
 115 func TestParseEnGnbSetupRequest_Success(t *testing.T) {
 116         enGnbXml := readXmlFile(t, EnGnbSetupRequestXmlPath)
 117         handler, _, _, _, _, _ := initMocks(t)
 118         prefBytes := []byte(e2SetupMsgPrefix)
 119         request, _, err := handler.parseSetupRequest(append(prefBytes, enGnbXml...))
 120         assert.Equal(t, "131014", request.GetPlmnId())
 121         assert.Equal(t, "11000101110001101100011111111000", request.GetNbId())
 122         assert.Nil(t, err)
 123 }
 124
 125 func TestParseNgEnbSetupRequest_Success(t *testing.T) {
 126         ngEnbXml := readXmlFile(t, NgEnbSetupRequestXmlPath)
 127         handler, _, _, _, _, _ := initMocks(t)
 128         prefBytes := []byte(e2SetupMsgPrefix)
 129         request, _, err := handler.parseSetupRequest(append(prefBytes, ngEnbXml...))
 130         assert.Equal(t, "131014", request.GetPlmnId())
 131         assert.Equal(t, "101010101010101010", request.GetNbId())
 132         assert.Nil(t, err)
 133 }
 134
 135 func TestParseEnbSetupRequest_Success(t *testing.T) {
 136         enbXml := readXmlFile(t, EnbSetupRequestXmlPath)
 137         handler, _, _, _, _, _ := initMocks(t)
 138         prefBytes := []byte(e2SetupMsgPrefix)
 139         request, _, err := handler.parseSetupRequest(append(prefBytes, enbXml...))
 140         assert.Equal(t, "6359AB", request.GetPlmnId())
 141         assert.Equal(t, "101010101010101010", request.GetNbId())
 142         assert.Nil(t, err)
 143 }
 144
 145 func TestParseSetupRequest_PipFailure(t *testing.T) {
 146         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 147         handler, _, _, _, _, _ := initMocks(t)
 148         prefBytes := []byte("10.0.2.15:9999")
 149         request, _, err := handler.parseSetupRequest(append(prefBytes, xmlGnb...))
 150         assert.Nil(t, request)
 151         assert.NotNil(t, err)
 152         assert.EqualError(t, err, "#E2SetupRequestNotificationHandler.parseSetupRequest - Error parsing E2 Setup Request failed extract Payload: no | separator found")
 153 }
 154
 155 func TestParseSetupRequest_UnmarshalFailure(t *testing.T) {
 156         handler, _, _, _, _, _ := initMocks(t)
 157         prefBytes := []byte(e2SetupMsgPrefix)
 158         request, _, err := handler.parseSetupRequest(append(prefBytes, 1, 2, 3))
 159         assert.Nil(t, request)
 160         assert.NotNil(t, err)
 161         assert.EqualError(t, err, "#E2SetupRequestNotificationHandler.parseSetupRequest - Error unmarshalling E2 Setup Request payload: 31302e302e322e31353a393939397c010203")
 162 }
 163
 164 func TestE2SetupRequestNotificationHandler_HandleParseError(t *testing.T) {
 165         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 166         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 167         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 168         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte("invalid_prefix"), xmlGnb...)}
 169         handler.Handle(notificationRequest)
 170         readerMock.AssertNotCalled(t, "GetNodeb", mock.Anything)
 171         writerMock.AssertNotCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
 172         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 173         writerMock.AssertNotCalled(t, "UpdateNodebInfo", mock.Anything)
 174         e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
 175         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 176 }
 177
 178 func TestE2SetupRequestNotificationHandler_HandleUnmarshalError(t *testing.T) {
 179         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 180         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 181         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), "xmlGnb"...)}
 182         handler.Handle(notificationRequest)
 183         readerMock.AssertNotCalled(t, "GetNodeb", mock.Anything)
 184         writerMock.AssertNotCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
 185         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 186         writerMock.AssertNotCalled(t, "UpdateNodebInfo", mock.Anything)
 187         e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
 188         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 189 }
 190
 191 func TestE2SetupRequestNotificationHandler_ConvertTo20BitStringError(t *testing.T) {
 192         xmlEnGnb := readXmlFile(t, EnGnbSetupRequestXmlPath)
 193         logger := tests.InitLog(t)
 194         config := &configuration.Configuration{
 195                 RnibRetryIntervalMs:       10,
 196                 MaxRnibConnectionAttempts: 3,
 197                 RnibWriter: configuration.RnibWriterConfig{
 198                         StateChangeMessageChannel: StateChangeMessageChannel,
 199                 },
 200                 GlobalRicId: struct {
 201                         RicId string
 202                         Mcc   string
 203                         Mnc   string
 204                 }{Mcc: "327", Mnc: "94", RicId: "10011001101010101011"}}
 205         rmrMessengerMock := &mocks.RmrMessengerMock{}
 206         rmrSender := tests.InitRmrSender(rmrMessengerMock, logger)
 207         readerMock := &mocks.RnibReaderMock{}
 208         writerMock := &mocks.RnibWriterMock{}
 209         routingManagerClientMock := &mocks.RoutingManagerClientMock{}
 210         rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
 211         e2tInstancesManagerMock := &mocks.E2TInstancesManagerMock{}
 212         ranListManager := managers.NewRanListManager(logger, rnibDataService)
 213         ranAlarmService := services.NewRanAlarmService(logger, config)
 214         ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService, ranListManager, ranAlarmService)
 215
 216         e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManagerMock, routingManagerClientMock, ranConnectStatusChangeManager)
 217         handler := NewE2SetupRequestNotificationHandler(logger, config, e2tInstancesManagerMock, rmrSender, rnibDataService, e2tAssociationManager, ranConnectStatusChangeManager, ranListManager)
 218         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 219         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 220         var gnb *entities.NodebInfo
 221         readerMock.On("GetNodeb", mock.Anything).Return(gnb, common.NewResourceNotFoundError("Not found"))
 222         writerMock.On("SaveNodeb", mock.Anything, mock.Anything).Return(nil)
 223         writerMock.On("AddNbIdentity", entities.Node_GNB, mock.Anything).Return(nil)
 224         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", mock.Anything, mock.Anything).Return(nil)
 225         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 226         writerMock.On("UpdateNodebInfo", mock.Anything).Return(nil)
 227         e2tInstancesManagerMock.On("AddRansToInstance", mock.Anything, mock.Anything).Return(nil)
 228         var errEmpty error
 229         rmrMessage := &rmrCgo.MBuf{}
 230         rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(rmrMessage, errEmpty)
 231         prefBytes := []byte(e2SetupMsgPrefix)
 232         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append(prefBytes, xmlEnGnb...)}
 233         handler.Handle(notificationRequest)
 234         readerMock.AssertCalled(t, "GetNodeb", mock.Anything)
 235         e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceFullAddress)
 236         writerMock.AssertCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
 237         routingManagerClientMock.AssertCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 238         writerMock.AssertCalled(t, "UpdateNodebInfo", mock.Anything)
 239         e2tInstancesManagerMock.AssertCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
 240         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 241 }
 242
 243 func TestExtractionOfNodeTypeFromRanName(t *testing.T) {
 244         handler, _, _, _, _, _ := initMocks(t)
 245         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"}
 246         for _, v := range validRanNames {
 247                 nodeb := &entities.NodebInfo{RanName: v}
 248                 err := handler.setNodeTypeAndConfiguration(nodeb)
 249                 assert.Nil(t, err)
 250         }
 251         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"}
 252         for _, v := range inValidRanNames {
 253                 nodeb := &entities.NodebInfo{RanName: v}
 254                 err := handler.setNodeTypeAndConfiguration(nodeb)
 255                 assert.NotNil(t, err, v)
 256         }
 257 }
 258
 259 func TestE2SetupRequestNotificationHandler_GetGeneralConfigurationFailure(t *testing.T) {
 260         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 261         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 262         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{}, common.NewInternalError(errors.New("some error")))
 263         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 264         handler.Handle(notificationRequest)
 265         rmrMessengerMock.AssertNotCalled(t, "SendMsg")
 266         e2tInstancesManagerMock.AssertNotCalled(t, "GetE2TInstance")
 267         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance")
 268         readerMock.AssertNotCalled(t, "GetNodeb")
 269         writerMock.AssertNotCalled(t, "SaveNodeb")
 270 }
 271
 272 func TestE2SetupRequestNotificationHandler_EnableRicFalse(t *testing.T) {
 273         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 274         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 275         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: false}, nil)
 276         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 277         mbuf := getMbuf(gnbNodebRanName, rmrCgo.RIC_E2_SETUP_FAILURE, E2SetupFailureResponseWithMiscCause, notificationRequest)
 278         rmrMessengerMock.On("WhSendMsg", mbuf, true).Return(&rmrCgo.MBuf{}, nil)
 279         handler.Handle(notificationRequest)
 280         rmrMessengerMock.AssertCalled(t, "WhSendMsg", mbuf, true)
 281         e2tInstancesManagerMock.AssertNotCalled(t, "GetE2TInstance")
 282         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance")
 283         readerMock.AssertNotCalled(t, "GetNodeb")
 284         writerMock.AssertNotCalled(t, "SaveNodeb")
 285 }
 286
 287 func TestE2SetupRequestNotificationHandler_HandleGetE2TInstanceError(t *testing.T) {
 288         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 289         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 290         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 291         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, common.NewResourceNotFoundError("Not found"))
 292         prefBytes := []byte(e2SetupMsgPrefix)
 293         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append(prefBytes, xmlGnb...)}
 294         handler.Handle(notificationRequest)
 295         e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceFullAddress)
 296         readerMock.AssertNotCalled(t, "GetNodeb", mock.Anything)
 297         writerMock.AssertNotCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
 298         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 299         writerMock.AssertNotCalled(t, "UpdateNodebInfo", mock.Anything)
 300         e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
 301         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 302 }
 303
 304 func TestE2SetupRequestNotificationHandler_HandleGetNodebError(t *testing.T) {
 305         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 306         handler, readerMock, writerMock, routingManagerClientMock, e2tInstancesManagerMock, rmrMessengerMock := initMocks(t)
 307         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 308         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 309         var gnb *entities.NodebInfo
 310         readerMock.On("GetNodeb", mock.Anything).Return(gnb, common.NewInternalError(errors.New("some error")))
 311         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 312         handler.Handle(notificationRequest)
 313         e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceFullAddress)
 314         readerMock.AssertCalled(t, "GetNodeb", mock.Anything)
 315         writerMock.AssertNotCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
 316         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 317         writerMock.AssertNotCalled(t, "UpdateNodebInfo", mock.Anything)
 318         e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
 319         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 320 }
 321
 322 /* New Ran UTs - BEGIN */
 323
 324 func TestE2SetupRequestNotificationHandler_HandleNewRanSaveNodebFailure(t *testing.T) {
 325         xml := readXmlFile(t, GnbSetupRequestXmlPath)
 326         handler, readerMock, writerMock, _, e2tInstancesManagerMock, _ := initMocks(t)
 327         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 328         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 329         var gnb *entities.NodebInfo
 330         readerMock.On("GetNodeb", gnbNodebRanName).Return(gnb, common.NewResourceNotFoundError("Not found"))
 331         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xml...)}
 332         nodebInfo := getExpectedGnbNodebForNewRan(notificationRequest.Payload)
 333         writerMock.On("SaveNodeb", nodebInfo).Return(common.NewInternalError(errors.New("error")))
 334         handler.Handle(notificationRequest)
 335
 336         readerMock.AssertExpectations(t)
 337         writerMock.AssertExpectations(t)
 338         e2tInstancesManagerMock.AssertExpectations(t)
 339 }
 340
 341 func TestE2SetupRequestNotificationHandler_HandleNewRan_invalidRanName(t *testing.T) {
 342         xml := readXmlFile(t, EnbSetupRequestXmlPath)
 343         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initMocks(t)
 344         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 345         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 346         var enb *entities.NodebInfo
 347         invalidEnbRanName := "enB-macro:P310-410-b5c67788"
 348         readerMock.On("GetNodeb", invalidEnbRanName).Return(enb, common.NewResourceNotFoundError("Not found"))
 349         notificationRequest := &models.NotificationRequest{RanName: invalidEnbRanName, Payload: append([]byte(e2SetupMsgPrefix), xml...)}
 350         mbuf := getMbuf(invalidEnbRanName, rmrCgo.RIC_E2_SETUP_FAILURE, E2SetupFailureResponseWithRicCause, notificationRequest)
 351         rmrMessengerMock.On("WhSendMsg", mbuf, true).Return(&rmrCgo.MBuf{}, nil)
 352         handler.Handle(notificationRequest)
 353
 354         readerMock.AssertExpectations(t)
 355         writerMock.AssertExpectations(t)
 356         rmrMessengerMock.AssertCalled(t, "WhSendMsg", mbuf, true)
 357         e2tInstancesManagerMock.AssertExpectations(t)
 358 }
 359
 360 func TestE2SetupRequestNotificationHandler_HandleNewRanAddNbIdentityFailure(t *testing.T) {
 361         xml := readXmlFile(t, GnbSetupRequestXmlPath)
 362         handler, readerMock, writerMock, _, e2tInstancesManagerMock, _ := initMocks(t)
 363         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 364         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 365         var gnb *entities.NodebInfo
 366         readerMock.On("GetNodeb", gnbNodebRanName).Return(gnb, common.NewResourceNotFoundError("Not found"))
 367         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xml...)}
 368         nodebInfo := getExpectedGnbNodebForNewRan(notificationRequest.Payload)
 369         writerMock.On("SaveNodeb", nodebInfo).Return(nil)
 370         nbIdentity := &entities.NbIdentity{InventoryName: gnbNodebRanName, GlobalNbId: nodebInfo.GlobalNbId}
 371         writerMock.On("AddNbIdentity", entities.Node_GNB, nbIdentity).Return(common.NewInternalError(errors.New("error")))
 372         handler.Handle(notificationRequest)
 373         readerMock.AssertExpectations(t)
 374         writerMock.AssertExpectations(t)
 375         e2tInstancesManagerMock.AssertExpectations(t)
 376 }
 377
 378 func TestE2SetupRequestNotificationHandler_HandleNewRanRoutingManagerError(t *testing.T) {
 379         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 380
 381         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 382         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 383         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 384         readerMock.On("GetNodeb", gnbNodebRanName).Return(&entities.NodebInfo{}, common.NewResourceNotFoundError("Not found"))
 385         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 386         nodebInfo := getExpectedGnbNodebForNewRan(notificationRequest.Payload)
 387         writerMock.On("SaveNodeb", nodebInfo).Return(nil)
 388         nbIdentity := &entities.NbIdentity{InventoryName: gnbNodebRanName, GlobalNbId: nodebInfo.GlobalNbId}
 389         writerMock.On("AddNbIdentity", entities.Node_GNB, nbIdentity).Return(nil)
 390         updatedNodebInfo := *nodebInfo
 391         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(errors.New("association error"))
 392         updatedNodebInfo.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
 393         writerMock.On("UpdateNodebInfo", &updatedNodebInfo).Return(nil)
 394         var errEmpty error
 395         mbuf := getMbuf(gnbNodebRanName, rmrCgo.RIC_E2_SETUP_FAILURE, E2SetupFailureResponseWithTransportCause, notificationRequest)
 396         rmrMessengerMock.On("WhSendMsg", mbuf, true).Return(&rmrCgo.MBuf{}, errEmpty)
 397         handler.Handle(notificationRequest)
 398         readerMock.AssertExpectations(t)
 399         e2tInstancesManagerMock.AssertExpectations(t)
 400         writerMock.AssertExpectations(t)
 401         routingManagerClientMock.AssertCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 402         e2tInstancesManagerMock.AssertExpectations(t)
 403         rmrMessengerMock.AssertCalled(t, "WhSendMsg", mbuf, true)
 404 }
 405
 406 func testE2SetupRequestNotificationHandler_HandleNewRanSuccess(t *testing.T, xmlPath string, nodeType entities.Node_Type) {
 407         xml := readXmlFile(t, xmlPath)
 408         var ranName string
 409         if nodeType == entities.Node_GNB {
 410                 ranName = gnbNodebRanName
 411         } else {
 412                 ranName = enbNodebRanName
 413         }
 414         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 415         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 416         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 417         var gnb *entities.NodebInfo
 418         readerMock.On("GetNodeb", ranName).Return(gnb, common.NewResourceNotFoundError("Not found"))
 419         notificationRequest := &models.NotificationRequest{RanName: ranName, Payload: append([]byte(e2SetupMsgPrefix), xml...)}
 420         var expectedNodebInfo *entities.NodebInfo
 421         if nodeType == entities.Node_GNB {
 422                 expectedNodebInfo = getExpectedGnbNodebForNewRan(notificationRequest.Payload)
 423         } else {
 424                 expectedNodebInfo = getExpectedEnbNodebForNewRan(notificationRequest.Payload)
 425         }
 426         writerMock.On("SaveNodeb", expectedNodebInfo).Return(nil)
 427         nbIdentity := &entities.NbIdentity{InventoryName: ranName, GlobalNbId: expectedNodebInfo.GlobalNbId}
 428         writerMock.On("AddNbIdentity", nodeType, nbIdentity).Return(nil)
 429         updatedNodebInfo := *expectedNodebInfo
 430         updatedNodebInfo.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 431         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &updatedNodebInfo, ranName+"_CONNECTED").Return(nil)
 432         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 433         updatedNodebInfo2 := *expectedNodebInfo
 434         updatedNodebInfo2.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 435         updatedNodebInfo2.AssociatedE2TInstanceAddress = e2tInstanceFullAddress
 436         writerMock.On("UpdateNodebInfo", &updatedNodebInfo2).Return(nil)
 437         e2tInstancesManagerMock.On("AddRansToInstance", e2tInstanceFullAddress, []string{ranName}).Return(nil)
 438         rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(&rmrCgo.MBuf{}, nil)
 439
 440         handler.Handle(notificationRequest)
 441
 442         readerMock.AssertExpectations(t)
 443         writerMock.AssertExpectations(t)
 444         e2tInstancesManagerMock.AssertExpectations(t)
 445 }
 446
 447 func TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess(t *testing.T) {
 448         testE2SetupRequestNotificationHandler_HandleNewRanSuccess(t, GnbSetupRequestXmlPath, entities.Node_GNB)
 449 }
 450
 451 func TestE2SetupRequestNotificationHandler_HandleNewGnbWithoutFunctionsSuccess(t *testing.T) {
 452         testE2SetupRequestNotificationHandler_HandleNewRanSuccess(t, GnbWithoutFunctionsSetupRequestXmlPath, entities.Node_GNB)
 453 }
 454
 455 func TestE2SetupRequestNotificationHandler_HandleNewEnGnbSuccess(t *testing.T) {
 456         testE2SetupRequestNotificationHandler_HandleNewRanSuccess(t, EnGnbSetupRequestXmlPath, entities.Node_GNB)
 457 }
 458
 459 func TestE2SetupRequestNotificationHandler_HandleNewNgEnbSuccess(t *testing.T) {
 460         testE2SetupRequestNotificationHandler_HandleNewRanSuccess(t, NgEnbSetupRequestXmlPath, entities.Node_ENB)
 461 }
 462
 463 func getExpectedGnbNodebForNewRan(payload []byte) *entities.NodebInfo {
 464         pipInd := bytes.IndexByte(payload, '|')
 465         setupRequest := &models.E2SetupRequestMessage{}
 466         _ = xml.Unmarshal(normalizeXml(payload[pipInd+1:]), &setupRequest.E2APPDU)
 467
 468         nodeb := &entities.NodebInfo{
 469                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 470                 RanName:                      gnbNodebRanName,
 471                 SetupFromNetwork:             true,
 472                 NodeType:                     entities.Node_GNB,
 473                 Configuration: &entities.NodebInfo_Gnb{
 474                         Gnb: &entities.Gnb{
 475                                 GnbType:      entities.GnbType_GNB,
 476                                 RanFunctions: setupRequest.ExtractRanFunctionsList(),
 477                         },
 478                 },
 479                 GlobalNbId: &entities.GlobalNbId{
 480                         PlmnId: setupRequest.GetPlmnId(),
 481                         NbId:   setupRequest.GetNbId(),
 482                 },
 483         }
 484
 485         return nodeb
 486 }
 487
 488 func getExpectedEnbNodebForNewRan(payload []byte) *entities.NodebInfo {
 489         pipInd := bytes.IndexByte(payload, '|')
 490         setupRequest := &models.E2SetupRequestMessage{}
 491         _ = xml.Unmarshal(normalizeXml(payload[pipInd+1:]), &setupRequest.E2APPDU)
 492
 493         nodeb := &entities.NodebInfo{
 494                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 495                 RanName:                      enbNodebRanName,
 496                 SetupFromNetwork:             true,
 497                 NodeType:                     entities.Node_ENB,
 498                 Configuration: &entities.NodebInfo_Enb{
 499                         Enb: &entities.Enb{
 500                                 EnbType: entities.EnbType_MACRO_ENB,
 501                         },
 502                 },
 503                 GlobalNbId: &entities.GlobalNbId{
 504                         PlmnId: setupRequest.GetPlmnId(),
 505                         NbId:   setupRequest.GetNbId(),
 506                 },
 507         }
 508
 509         return nodeb
 510 }
 511
 512 /* New Ran UTs - END */
 513
 514 /* Existing Ran UTs - BEGIN */
 515
 516 func getExpectedNodebForExistingRan(nodeb entities.NodebInfo, payload []byte) *entities.NodebInfo {
 517         pipInd := bytes.IndexByte(payload, '|')
 518         setupRequest := &models.E2SetupRequestMessage{}
 519         _ = xml.Unmarshal(normalizeXml(payload[pipInd+1:]), &setupRequest.E2APPDU)
 520
 521         if nodeb.NodeType == entities.Node_ENB {
 522                 return &nodeb
 523         }
 524
 525         if ranFuncs := setupRequest.ExtractRanFunctionsList(); ranFuncs != nil {
 526                 nodeb.GetGnb().RanFunctions = ranFuncs
 527         }
 528         return &nodeb
 529 }
 530
 531 func TestE2SetupRequestNotificationHandler_HandleExistingConnectedEnbSuccess(t *testing.T) {
 532         xmlEnb := readXmlFile(t, EnbSetupRequestXmlPath)
 533         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 534         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 535         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 536         var nodebInfo = &entities.NodebInfo{
 537                 RanName:                      enbNodebRanName,
 538                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 539                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 540                 NodeType:                     entities.Node_ENB,
 541                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{}},
 542         }
 543
 544         readerMock.On("GetNodeb", enbNodebRanName).Return(nodebInfo, nil)
 545         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 546
 547         notificationRequest := &models.NotificationRequest{RanName: enbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlEnb...)}
 548         enbToUpdate := getExpectedNodebForExistingRan(*nodebInfo, notificationRequest.Payload)
 549
 550         writerMock.On("UpdateNodebInfo", enbToUpdate).Return(nil)
 551         e2tInstancesManagerMock.On("AddRansToInstance", e2tInstanceFullAddress, []string{enbNodebRanName}).Return(nil)
 552         var errEmpty error
 553         rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(&rmrCgo.MBuf{}, errEmpty)
 554         handler.Handle(notificationRequest)
 555         readerMock.AssertExpectations(t)
 556         writerMock.AssertExpectations(t)
 557         e2tInstancesManagerMock.AssertExpectations(t)
 558         rmrMessengerMock.AssertCalled(t, "SendMsg", mock.Anything, true)
 559 }
 560
 561 func TestE2SetupRequestNotificationHandler_HandleExistingDisconnectedEnbSuccess(t *testing.T) {
 562         xmlEnb := readXmlFile(t, EnbSetupRequestXmlPath)
 563         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 564         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 565         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 566         var nodebInfo = &entities.NodebInfo{
 567                 RanName:                      enbNodebRanName,
 568                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 569                 ConnectionStatus:             entities.ConnectionStatus_DISCONNECTED,
 570                 NodeType:                     entities.Node_ENB,
 571                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{}},
 572         }
 573
 574         readerMock.On("GetNodeb", enbNodebRanName).Return(nodebInfo, nil)
 575         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 576
 577         notificationRequest := &models.NotificationRequest{RanName: enbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlEnb...)}
 578         enbToUpdate := getExpectedNodebForExistingRan(*nodebInfo, notificationRequest.Payload)
 579
 580         enbToUpdate2 := *enbToUpdate
 581         enbToUpdate2.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 582         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &enbToUpdate2, enbNodebRanName+"_CONNECTED").Return(nil)
 583         enbToUpdate3 := *enbToUpdate
 584         enbToUpdate3.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 585         enbToUpdate3.AssociatedE2TInstanceAddress = e2tInstanceFullAddress
 586         writerMock.On("UpdateNodebInfo", &enbToUpdate3).Return(nil)
 587         e2tInstancesManagerMock.On("AddRansToInstance", e2tInstanceFullAddress, []string{enbNodebRanName}).Return(nil)
 588         var errEmpty error
 589         rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(&rmrCgo.MBuf{}, errEmpty)
 590         handler.Handle(notificationRequest)
 591         readerMock.AssertExpectations(t)
 592         writerMock.AssertExpectations(t)
 593         e2tInstancesManagerMock.AssertExpectations(t)
 594         rmrMessengerMock.AssertCalled(t, "SendMsg", mock.Anything, true)
 595 }
 596
 597 func testE2SetupRequestNotificationHandler_HandleExistingConnectedGnbSuccess(t *testing.T, withFunctions bool) {
 598         var xmlGnb []byte
 599
 600         if withFunctions {
 601                 xmlGnb = readXmlFile(t, GnbSetupRequestXmlPath)
 602
 603         } else {
 604                 xmlGnb = readXmlFile(t, GnbWithoutFunctionsSetupRequestXmlPath)
 605         }
 606         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 607         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 608         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 609         var nodebInfo = &entities.NodebInfo{
 610                 RanName:                      gnbNodebRanName,
 611                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 612                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 613                 NodeType:                     entities.Node_GNB,
 614                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
 615         }
 616
 617         if withFunctions {
 618                 gnb := nodebInfo.GetGnb()
 619                 gnb.RanFunctions = []*entities.RanFunction{{RanFunctionId: 2, RanFunctionRevision: 2}}
 620         }
 621
 622         readerMock.On("GetNodeb", gnbNodebRanName).Return(nodebInfo, nil)
 623         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 624
 625         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 626         gnbToUpdate := getExpectedNodebForExistingRan(*nodebInfo, notificationRequest.Payload)
 627
 628         writerMock.On("UpdateNodebInfo", gnbToUpdate).Return(nil)
 629         if withFunctions {
 630                 writerMock.On("UpdateNodebInfoAndPublish", gnbToUpdate).Return(nil)
 631         }
 632         e2tInstancesManagerMock.On("AddRansToInstance", e2tInstanceFullAddress, []string{gnbNodebRanName}).Return(nil)
 633         var errEmpty error
 634         rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(&rmrCgo.MBuf{}, errEmpty)
 635         handler.Handle(notificationRequest)
 636         readerMock.AssertExpectations(t)
 637         writerMock.AssertExpectations(t)
 638         e2tInstancesManagerMock.AssertExpectations(t)
 639         rmrMessengerMock.AssertCalled(t, "SendMsg", mock.Anything, true)
 640 }
 641
 642 func TestE2SetupRequestNotificationHandler_HandleExistingConnectedGnbRoutingManagerError(t *testing.T) {
 643         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 644         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 645         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 646         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 647         var nodebInfo = &entities.NodebInfo{
 648                 RanName:                      gnbNodebRanName,
 649                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 650                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 651                 NodeType:                     entities.Node_GNB,
 652                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
 653         }
 654
 655         gnb := nodebInfo.GetGnb()
 656         gnb.RanFunctions = []*entities.RanFunction{{RanFunctionId: 2, RanFunctionRevision: 2}}
 657
 658         readerMock.On("GetNodeb", gnbNodebRanName).Return(nodebInfo, nil)
 659         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(errors.New("association error"))
 660
 661         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 662         gnbToUpdate := getExpectedNodebForExistingRan(*nodebInfo, notificationRequest.Payload)
 663
 664         gnbToUpdate2 := *gnbToUpdate
 665         gnbToUpdate2.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
 666         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &gnbToUpdate2, gnbNodebRanName+"_DISCONNECTED").Return(nil)
 667
 668         var errEmpty error
 669         rmrMessengerMock.On("WhSendMsg", mock.Anything, true).Return(&rmrCgo.MBuf{}, errEmpty)
 670         handler.Handle(notificationRequest)
 671         readerMock.AssertExpectations(t)
 672         writerMock.AssertExpectations(t)
 673         e2tInstancesManagerMock.AssertExpectations(t)
 674         rmrMessengerMock.AssertCalled(t, "WhSendMsg", mock.Anything, true)
 675 }
 676
 677 func TestE2SetupRequestNotificationHandler_HandleExistingGnbInvalidConnectionStatusError(t *testing.T) {
 678         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 679         handler, readerMock, writerMock, _, e2tInstancesManagerMock, rmrMessengerMock := initMocks(t)
 680         var gnb = &entities.NodebInfo{RanName: gnbNodebRanName, ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 681         readerMock.On("GetNodeb", gnbNodebRanName).Return(gnb, nil)
 682         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 683         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 684         prefBytes := []byte(e2SetupMsgPrefix)
 685         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append(prefBytes, xmlGnb...)}
 686         handler.Handle(notificationRequest)
 687         readerMock.AssertExpectations(t)
 688         writerMock.AssertExpectations(t)
 689         e2tInstancesManagerMock.AssertExpectations(t)
 690         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 691 }
 692
 693 func TestE2SetupRequestNotificationHandler_HandleExistingConnectedGnbWithoutFunctionsSuccess(t *testing.T) {
 694         testE2SetupRequestNotificationHandler_HandleExistingConnectedGnbSuccess(t, false)
 695 }
 696
 697 func TestE2SetupRequestNotificationHandler_HandleExistingConnectedGnbWithFunctionsSuccess(t *testing.T) {
 698         testE2SetupRequestNotificationHandler_HandleExistingConnectedGnbSuccess(t, true)
 699 }
 700
 701 func TestE2SetupRequestNotificationHandler_HandleExistingDisconnectedGnbSuccess(t *testing.T) {
 702         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 703         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 704         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 705         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 706         var nodebInfo = &entities.NodebInfo{
 707                 RanName:                      gnbNodebRanName,
 708                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 709                 ConnectionStatus:             entities.ConnectionStatus_DISCONNECTED,
 710                 NodeType:                     entities.Node_GNB,
 711                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
 712         }
 713
 714         readerMock.On("GetNodeb", gnbNodebRanName).Return(nodebInfo, nil)
 715         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 716
 717         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 718         gnbToUpdate := getExpectedNodebForExistingRan(*nodebInfo, notificationRequest.Payload)
 719         gnbToUpdate2 := *gnbToUpdate
 720         gnbToUpdate2.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 721         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &gnbToUpdate2, gnbNodebRanName+"_CONNECTED").Return(nil)
 722         gnbToUpdate3 := *gnbToUpdate
 723         gnbToUpdate3.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 724         gnbToUpdate3.AssociatedE2TInstanceAddress = e2tInstanceFullAddress
 725         writerMock.On("UpdateNodebInfo", &gnbToUpdate3).Return(nil)
 726         e2tInstancesManagerMock.On("AddRansToInstance", e2tInstanceFullAddress, []string{gnbNodebRanName}).Return(nil)
 727         var errEmpty error
 728         rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(&rmrCgo.MBuf{}, errEmpty)
 729         handler.Handle(notificationRequest)
 730         readerMock.AssertExpectations(t)
 731         writerMock.AssertExpectations(t)
 732         e2tInstancesManagerMock.AssertExpectations(t)
 733 }
 734
 735 /* Existing Ran UTs - END */