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         enbToUpdate.SetupFromNetwork = true
 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         enbToUpdate2.SetupFromNetwork = true
 583         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &enbToUpdate2, enbNodebRanName+"_CONNECTED").Return(nil)
 584         enbToUpdate3 := *enbToUpdate
 585         enbToUpdate3.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 586         enbToUpdate3.SetupFromNetwork = true
 587         enbToUpdate3.AssociatedE2TInstanceAddress = e2tInstanceFullAddress
 588         writerMock.On("UpdateNodebInfo", &enbToUpdate3).Return(nil)
 589         e2tInstancesManagerMock.On("AddRansToInstance", e2tInstanceFullAddress, []string{enbNodebRanName}).Return(nil)
 590         var errEmpty error
 591         rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(&rmrCgo.MBuf{}, errEmpty)
 592         handler.Handle(notificationRequest)
 593         readerMock.AssertExpectations(t)
 594         writerMock.AssertExpectations(t)
 595         e2tInstancesManagerMock.AssertExpectations(t)
 596         rmrMessengerMock.AssertCalled(t, "SendMsg", mock.Anything, true)
 597 }
 598
 599 func testE2SetupRequestNotificationHandler_HandleExistingConnectedGnbSuccess(t *testing.T, withFunctions bool) {
 600         var xmlGnb []byte
 601
 602         if withFunctions {
 603                 xmlGnb = readXmlFile(t, GnbSetupRequestXmlPath)
 604
 605         } else {
 606                 xmlGnb = readXmlFile(t, GnbWithoutFunctionsSetupRequestXmlPath)
 607         }
 608         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 609         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 610         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 611         var nodebInfo = &entities.NodebInfo{
 612                 RanName:                      gnbNodebRanName,
 613                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 614                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 615                 NodeType:                     entities.Node_GNB,
 616                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
 617         }
 618
 619         if withFunctions {
 620                 gnb := nodebInfo.GetGnb()
 621                 gnb.RanFunctions = []*entities.RanFunction{{RanFunctionId: 2, RanFunctionRevision: 2}}
 622         }
 623
 624         readerMock.On("GetNodeb", gnbNodebRanName).Return(nodebInfo, nil)
 625         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 626
 627         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 628         gnbToUpdate := getExpectedNodebForExistingRan(*nodebInfo, notificationRequest.Payload)
 629         gnbToUpdate.SetupFromNetwork = true
 630         writerMock.On("UpdateNodebInfo", gnbToUpdate).Return(nil)
 631         if withFunctions {
 632                 writerMock.On("UpdateNodebInfoAndPublish", gnbToUpdate).Return(nil)
 633         }
 634         e2tInstancesManagerMock.On("AddRansToInstance", e2tInstanceFullAddress, []string{gnbNodebRanName}).Return(nil)
 635         var errEmpty error
 636         rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(&rmrCgo.MBuf{}, errEmpty)
 637         handler.Handle(notificationRequest)
 638         readerMock.AssertExpectations(t)
 639         writerMock.AssertExpectations(t)
 640         e2tInstancesManagerMock.AssertExpectations(t)
 641         rmrMessengerMock.AssertCalled(t, "SendMsg", mock.Anything, true)
 642 }
 643
 644 func TestE2SetupRequestNotificationHandler_HandleExistingConnectedGnbRoutingManagerError(t *testing.T) {
 645         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 646         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 647         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 648         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 649         var nodebInfo = &entities.NodebInfo{
 650                 RanName:                      gnbNodebRanName,
 651                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 652                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 653                 NodeType:                     entities.Node_GNB,
 654                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
 655         }
 656
 657         gnb := nodebInfo.GetGnb()
 658         gnb.RanFunctions = []*entities.RanFunction{{RanFunctionId: 2, RanFunctionRevision: 2}}
 659
 660         readerMock.On("GetNodeb", gnbNodebRanName).Return(nodebInfo, nil)
 661         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(errors.New("association error"))
 662
 663         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 664         gnbToUpdate := getExpectedNodebForExistingRan(*nodebInfo, notificationRequest.Payload)
 665
 666         gnbToUpdate2 := *gnbToUpdate
 667         gnbToUpdate2.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
 668         gnbToUpdate2.SetupFromNetwork = true
 669         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &gnbToUpdate2, gnbNodebRanName+"_DISCONNECTED").Return(nil)
 670
 671         var errEmpty error
 672         rmrMessengerMock.On("WhSendMsg", mock.Anything, true).Return(&rmrCgo.MBuf{}, errEmpty)
 673         handler.Handle(notificationRequest)
 674         readerMock.AssertExpectations(t)
 675         writerMock.AssertExpectations(t)
 676         e2tInstancesManagerMock.AssertExpectations(t)
 677         rmrMessengerMock.AssertCalled(t, "WhSendMsg", mock.Anything, true)
 678 }
 679
 680 func TestE2SetupRequestNotificationHandler_HandleExistingGnbInvalidConnectionStatusError(t *testing.T) {
 681         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 682         handler, readerMock, writerMock, _, e2tInstancesManagerMock, rmrMessengerMock := initMocks(t)
 683         var gnb = &entities.NodebInfo{RanName: gnbNodebRanName, ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 684         readerMock.On("GetNodeb", gnbNodebRanName).Return(gnb, nil)
 685         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 686         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 687         prefBytes := []byte(e2SetupMsgPrefix)
 688         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append(prefBytes, xmlGnb...)}
 689         handler.Handle(notificationRequest)
 690         readerMock.AssertExpectations(t)
 691         writerMock.AssertExpectations(t)
 692         e2tInstancesManagerMock.AssertExpectations(t)
 693         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 694 }
 695
 696 func TestE2SetupRequestNotificationHandler_HandleExistingConnectedGnbWithoutFunctionsSuccess(t *testing.T) {
 697         testE2SetupRequestNotificationHandler_HandleExistingConnectedGnbSuccess(t, false)
 698 }
 699
 700 func TestE2SetupRequestNotificationHandler_HandleExistingConnectedGnbWithFunctionsSuccess(t *testing.T) {
 701         testE2SetupRequestNotificationHandler_HandleExistingConnectedGnbSuccess(t, true)
 702 }
 703
 704 func TestE2SetupRequestNotificationHandler_HandleExistingDisconnectedGnbSuccess(t *testing.T) {
 705         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 706         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 707         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 708         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 709         var nodebInfo = &entities.NodebInfo{
 710                 RanName:                      gnbNodebRanName,
 711                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 712                 ConnectionStatus:             entities.ConnectionStatus_DISCONNECTED,
 713                 NodeType:                     entities.Node_GNB,
 714                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
 715         }
 716
 717         readerMock.On("GetNodeb", gnbNodebRanName).Return(nodebInfo, nil)
 718         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 719
 720         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 721         gnbToUpdate := getExpectedNodebForExistingRan(*nodebInfo, notificationRequest.Payload)
 722         gnbToUpdate2 := *gnbToUpdate
 723         gnbToUpdate2.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 724         gnbToUpdate2.SetupFromNetwork = true
 725         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &gnbToUpdate2, gnbNodebRanName+"_CONNECTED").Return(nil)
 726         gnbToUpdate3 := *gnbToUpdate
 727         gnbToUpdate3.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 728         gnbToUpdate3.SetupFromNetwork = true
 729         gnbToUpdate3.AssociatedE2TInstanceAddress = e2tInstanceFullAddress
 730         writerMock.On("UpdateNodebInfo", &gnbToUpdate3).Return(nil)
 731         e2tInstancesManagerMock.On("AddRansToInstance", e2tInstanceFullAddress, []string{gnbNodebRanName}).Return(nil)
 732         var errEmpty error
 733         rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(&rmrCgo.MBuf{}, errEmpty)
 734         handler.Handle(notificationRequest)
 735         readerMock.AssertExpectations(t)
 736         writerMock.AssertExpectations(t)
 737         e2tInstancesManagerMock.AssertExpectations(t)
 738 }
 739
 740 /* Existing Ran UTs - END */