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