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, managers.RanListManager) {
  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, ranListManager
  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         writerMock.On("UpdateNbIdentities", mock.Anything, mock.Anything, mock.Anything).Return(nil)
 229         e2tInstancesManagerMock.On("AddRansToInstance", mock.Anything, mock.Anything).Return(nil)
 230         var errEmpty error
 231         rmrMessage := &rmrCgo.MBuf{}
 232         rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(rmrMessage, errEmpty)
 233         prefBytes := []byte(e2SetupMsgPrefix)
 234         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append(prefBytes, xmlEnGnb...)}
 235         handler.Handle(notificationRequest)
 236         readerMock.AssertCalled(t, "GetNodeb", mock.Anything)
 237         e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceFullAddress)
 238         writerMock.AssertCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
 239         routingManagerClientMock.AssertCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 240         writerMock.AssertCalled(t, "UpdateNodebInfo", mock.Anything)
 241         e2tInstancesManagerMock.AssertCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
 242         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 243 }
 244
 245 func TestExtractionOfNodeTypeFromRanName(t *testing.T) {
 246         handler, _, _, _, _, _, _ := initMocks(t)
 247         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"}
 248         for _, v := range validRanNames {
 249                 nodeb := &entities.NodebInfo{RanName: v}
 250                 err := handler.setNodeTypeAndConfiguration(nodeb)
 251                 assert.Nil(t, err)
 252         }
 253         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"}
 254         for _, v := range inValidRanNames {
 255                 nodeb := &entities.NodebInfo{RanName: v}
 256                 err := handler.setNodeTypeAndConfiguration(nodeb)
 257                 assert.NotNil(t, err, v)
 258         }
 259 }
 260
 261 func TestE2SetupRequestNotificationHandler_GetGeneralConfigurationFailure(t *testing.T) {
 262         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 263         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, _ := initMocks(t)
 264         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{}, common.NewInternalError(errors.New("some error")))
 265         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 266         handler.Handle(notificationRequest)
 267         rmrMessengerMock.AssertNotCalled(t, "SendMsg")
 268         e2tInstancesManagerMock.AssertNotCalled(t, "GetE2TInstance")
 269         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance")
 270         readerMock.AssertNotCalled(t, "GetNodeb")
 271         writerMock.AssertNotCalled(t, "SaveNodeb")
 272 }
 273
 274 func TestE2SetupRequestNotificationHandler_EnableRicFalse(t *testing.T) {
 275         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 276         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, _ := initMocks(t)
 277         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: false}, nil)
 278         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 279         mbuf := getMbuf(gnbNodebRanName, rmrCgo.RIC_E2_SETUP_FAILURE, E2SetupFailureResponseWithMiscCause, notificationRequest)
 280         rmrMessengerMock.On("WhSendMsg", mbuf, true).Return(&rmrCgo.MBuf{}, nil)
 281         handler.Handle(notificationRequest)
 282         rmrMessengerMock.AssertCalled(t, "WhSendMsg", mbuf, true)
 283         e2tInstancesManagerMock.AssertNotCalled(t, "GetE2TInstance")
 284         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance")
 285         readerMock.AssertNotCalled(t, "GetNodeb")
 286         writerMock.AssertNotCalled(t, "SaveNodeb")
 287 }
 288
 289 func TestE2SetupRequestNotificationHandler_HandleGetE2TInstanceError(t *testing.T) {
 290         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 291         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, _ := initMocks(t)
 292         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 293         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, common.NewResourceNotFoundError("Not found"))
 294         prefBytes := []byte(e2SetupMsgPrefix)
 295         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append(prefBytes, xmlGnb...)}
 296         handler.Handle(notificationRequest)
 297         e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceFullAddress)
 298         readerMock.AssertNotCalled(t, "GetNodeb", mock.Anything)
 299         writerMock.AssertNotCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
 300         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 301         writerMock.AssertNotCalled(t, "UpdateNodebInfo", mock.Anything)
 302         e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
 303         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 304 }
 305
 306 func TestE2SetupRequestNotificationHandler_HandleGetNodebError(t *testing.T) {
 307         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 308         handler, readerMock, writerMock, routingManagerClientMock, e2tInstancesManagerMock, rmrMessengerMock, _ := initMocks(t)
 309         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 310         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 311         var gnb *entities.NodebInfo
 312         readerMock.On("GetNodeb", mock.Anything).Return(gnb, common.NewInternalError(errors.New("some error")))
 313         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 314         handler.Handle(notificationRequest)
 315         e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceFullAddress)
 316         readerMock.AssertCalled(t, "GetNodeb", mock.Anything)
 317         writerMock.AssertNotCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
 318         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 319         writerMock.AssertNotCalled(t, "UpdateNodebInfo", mock.Anything)
 320         e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
 321         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 322 }
 323
 324 /* New Ran UTs - BEGIN */
 325
 326 func TestE2SetupRequestNotificationHandler_HandleNewRanSaveNodebFailure(t *testing.T) {
 327         xml := readXmlFile(t, GnbSetupRequestXmlPath)
 328         handler, readerMock, writerMock, _, e2tInstancesManagerMock, _, _ := initMocks(t)
 329         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 330         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 331         var gnb *entities.NodebInfo
 332         readerMock.On("GetNodeb", gnbNodebRanName).Return(gnb, common.NewResourceNotFoundError("Not found"))
 333         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xml...)}
 334         nodebInfo := getExpectedGnbNodebForNewRan(notificationRequest.Payload)
 335         writerMock.On("SaveNodeb", nodebInfo).Return(common.NewInternalError(errors.New("error")))
 336         handler.Handle(notificationRequest)
 337
 338         readerMock.AssertExpectations(t)
 339         writerMock.AssertExpectations(t)
 340         e2tInstancesManagerMock.AssertExpectations(t)
 341 }
 342
 343 func TestE2SetupRequestNotificationHandler_HandleNewRan_invalidRanName(t *testing.T) {
 344         xml := readXmlFile(t, EnbSetupRequestXmlPath)
 345         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _, _ := initMocks(t)
 346         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 347         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 348         var enb *entities.NodebInfo
 349         invalidEnbRanName := "enB-macro:P310-410-b5c67788"
 350         readerMock.On("GetNodeb", invalidEnbRanName).Return(enb, common.NewResourceNotFoundError("Not found"))
 351         notificationRequest := &models.NotificationRequest{RanName: invalidEnbRanName, Payload: append([]byte(e2SetupMsgPrefix), xml...)}
 352         mbuf := getMbuf(invalidEnbRanName, rmrCgo.RIC_E2_SETUP_FAILURE, E2SetupFailureResponseWithRicCause, notificationRequest)
 353         rmrMessengerMock.On("WhSendMsg", mbuf, true).Return(&rmrCgo.MBuf{}, nil)
 354         handler.Handle(notificationRequest)
 355
 356         readerMock.AssertExpectations(t)
 357         writerMock.AssertExpectations(t)
 358         rmrMessengerMock.AssertCalled(t, "WhSendMsg", mbuf, true)
 359         e2tInstancesManagerMock.AssertExpectations(t)
 360 }
 361
 362 func TestE2SetupRequestNotificationHandler_HandleNewRanAddNbIdentityFailure(t *testing.T) {
 363         xml := readXmlFile(t, GnbSetupRequestXmlPath)
 364         handler, readerMock, writerMock, _, e2tInstancesManagerMock, _, _ := initMocks(t)
 365         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 366         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 367         var gnb *entities.NodebInfo
 368         readerMock.On("GetNodeb", gnbNodebRanName).Return(gnb, common.NewResourceNotFoundError("Not found"))
 369         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xml...)}
 370         nodebInfo := getExpectedGnbNodebForNewRan(notificationRequest.Payload)
 371         writerMock.On("SaveNodeb", nodebInfo).Return(nil)
 372         nbIdentity := &entities.NbIdentity{InventoryName: gnbNodebRanName, GlobalNbId: nodebInfo.GlobalNbId}
 373         writerMock.On("AddNbIdentity", entities.Node_GNB, nbIdentity).Return(common.NewInternalError(errors.New("error")))
 374         handler.Handle(notificationRequest)
 375         readerMock.AssertExpectations(t)
 376         writerMock.AssertExpectations(t)
 377         e2tInstancesManagerMock.AssertExpectations(t)
 378 }
 379
 380 func TestE2SetupRequestNotificationHandler_HandleNewRanRoutingManagerError(t *testing.T) {
 381         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 382
 383         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, _ := initMocks(t)
 384         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 385         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 386         readerMock.On("GetNodeb", gnbNodebRanName).Return(&entities.NodebInfo{}, common.NewResourceNotFoundError("Not found"))
 387         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 388         nodebInfo := getExpectedGnbNodebForNewRan(notificationRequest.Payload)
 389         writerMock.On("SaveNodeb", nodebInfo).Return(nil)
 390         nbIdentity := &entities.NbIdentity{InventoryName: gnbNodebRanName, GlobalNbId: nodebInfo.GlobalNbId}
 391         writerMock.On("AddNbIdentity", entities.Node_GNB, nbIdentity).Return(nil)
 392         updatedNodebInfo := *nodebInfo
 393         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(errors.New("association error"))
 394         updatedNodebInfo.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
 395         writerMock.On("UpdateNodebInfo", &updatedNodebInfo).Return(nil)
 396         writerMock.On("UpdateNbIdentities", mock.Anything, mock.Anything, mock.Anything).Return(nil)
 397         var errEmpty error
 398         mbuf := getMbuf(gnbNodebRanName, rmrCgo.RIC_E2_SETUP_FAILURE, E2SetupFailureResponseWithTransportCause, notificationRequest)
 399         rmrMessengerMock.On("WhSendMsg", mbuf, true).Return(&rmrCgo.MBuf{}, errEmpty)
 400         handler.Handle(notificationRequest)
 401         readerMock.AssertExpectations(t)
 402         e2tInstancesManagerMock.AssertExpectations(t)
 403         writerMock.AssertExpectations(t)
 404         routingManagerClientMock.AssertCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 405         e2tInstancesManagerMock.AssertExpectations(t)
 406         rmrMessengerMock.AssertCalled(t, "WhSendMsg", mbuf, true)
 407 }
 408
 409 func testE2SetupRequestNotificationHandler_HandleNewRanSuccess(t *testing.T, xmlPath string, nodeType entities.Node_Type) {
 410         xml := readXmlFile(t, xmlPath)
 411         var ranName string
 412         if nodeType == entities.Node_GNB {
 413                 ranName = gnbNodebRanName
 414         } else {
 415                 ranName = enbNodebRanName
 416         }
 417         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, _ := initMocks(t)
 418         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 419         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 420         var gnb *entities.NodebInfo
 421         readerMock.On("GetNodeb", ranName).Return(gnb, common.NewResourceNotFoundError("Not found"))
 422         notificationRequest := &models.NotificationRequest{RanName: ranName, Payload: append([]byte(e2SetupMsgPrefix), xml...)}
 423         var expectedNodebInfo *entities.NodebInfo
 424         if nodeType == entities.Node_GNB {
 425                 expectedNodebInfo = getExpectedGnbNodebForNewRan(notificationRequest.Payload)
 426         } else {
 427                 expectedNodebInfo = getExpectedEnbNodebForNewRan(notificationRequest.Payload)
 428         }
 429         writerMock.On("SaveNodeb", expectedNodebInfo).Return(nil)
 430         nbIdentity := &entities.NbIdentity{InventoryName: ranName, GlobalNbId: expectedNodebInfo.GlobalNbId}
 431         writerMock.On("AddNbIdentity", nodeType, nbIdentity).Return(nil)
 432         updatedNodebInfo := *expectedNodebInfo
 433         updatedNodebInfo.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 434         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &updatedNodebInfo, ranName+"_CONNECTED").Return(nil)
 435         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 436         updatedNodebInfo2 := *expectedNodebInfo
 437         updatedNodebInfo2.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 438         updatedNodebInfo2.AssociatedE2TInstanceAddress = e2tInstanceFullAddress
 439         writerMock.On("UpdateNodebInfo", &updatedNodebInfo2).Return(nil)
 440
 441         newNbIdentity := &entities.NbIdentity{InventoryName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: expectedNodebInfo.GlobalNbId}
 442         writerMock.On("UpdateNbIdentities", updatedNodebInfo2.GetNodeType(), []*entities.NbIdentity{nbIdentity}, []*entities.NbIdentity{newNbIdentity}).Return(nil)
 443
 444         e2tInstancesManagerMock.On("AddRansToInstance", e2tInstanceFullAddress, []string{ranName}).Return(nil)
 445         rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(&rmrCgo.MBuf{}, nil)
 446
 447         handler.Handle(notificationRequest)
 448
 449         readerMock.AssertExpectations(t)
 450         writerMock.AssertExpectations(t)
 451         e2tInstancesManagerMock.AssertExpectations(t)
 452 }
 453
 454 func TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess(t *testing.T) {
 455         testE2SetupRequestNotificationHandler_HandleNewRanSuccess(t, GnbSetupRequestXmlPath, entities.Node_GNB)
 456 }
 457
 458 func TestE2SetupRequestNotificationHandler_HandleNewGnbWithoutFunctionsSuccess(t *testing.T) {
 459         testE2SetupRequestNotificationHandler_HandleNewRanSuccess(t, GnbWithoutFunctionsSetupRequestXmlPath, entities.Node_GNB)
 460 }
 461
 462 func TestE2SetupRequestNotificationHandler_HandleNewEnGnbSuccess(t *testing.T) {
 463         testE2SetupRequestNotificationHandler_HandleNewRanSuccess(t, EnGnbSetupRequestXmlPath, entities.Node_GNB)
 464 }
 465
 466 func TestE2SetupRequestNotificationHandler_HandleNewNgEnbSuccess(t *testing.T) {
 467         testE2SetupRequestNotificationHandler_HandleNewRanSuccess(t, NgEnbSetupRequestXmlPath, entities.Node_ENB)
 468 }
 469
 470 func getExpectedGnbNodebForNewRan(payload []byte) *entities.NodebInfo {
 471         pipInd := bytes.IndexByte(payload, '|')
 472         setupRequest := &models.E2SetupRequestMessage{}
 473         _ = xml.Unmarshal(normalizeXml(payload[pipInd+1:]), &setupRequest.E2APPDU)
 474
 475         nodeb := &entities.NodebInfo{
 476                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 477                 RanName:                      gnbNodebRanName,
 478                 SetupFromNetwork:             true,
 479                 NodeType:                     entities.Node_GNB,
 480                 Configuration: &entities.NodebInfo_Gnb{
 481                         Gnb: &entities.Gnb{
 482                                 GnbType:      entities.GnbType_GNB,
 483                                 RanFunctions: setupRequest.ExtractRanFunctionsList(),
 484                         },
 485                 },
 486                 GlobalNbId: &entities.GlobalNbId{
 487                         PlmnId: setupRequest.GetPlmnId(),
 488                         NbId:   setupRequest.GetNbId(),
 489                 },
 490         }
 491
 492         return nodeb
 493 }
 494
 495 func getExpectedEnbNodebForNewRan(payload []byte) *entities.NodebInfo {
 496         pipInd := bytes.IndexByte(payload, '|')
 497         setupRequest := &models.E2SetupRequestMessage{}
 498         _ = xml.Unmarshal(normalizeXml(payload[pipInd+1:]), &setupRequest.E2APPDU)
 499
 500         nodeb := &entities.NodebInfo{
 501                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 502                 RanName:                      enbNodebRanName,
 503                 SetupFromNetwork:             true,
 504                 NodeType:                     entities.Node_ENB,
 505                 Configuration: &entities.NodebInfo_Enb{
 506                         Enb: &entities.Enb{
 507                                 EnbType: entities.EnbType_MACRO_ENB,
 508                         },
 509                 },
 510                 GlobalNbId: &entities.GlobalNbId{
 511                         PlmnId: setupRequest.GetPlmnId(),
 512                         NbId:   setupRequest.GetNbId(),
 513                 },
 514         }
 515
 516         return nodeb
 517 }
 518
 519 /* New Ran UTs - END */
 520
 521 /* Existing Ran UTs - BEGIN */
 522
 523 func getExpectedNodebForExistingRan(nodeb *entities.NodebInfo, payload []byte) *entities.NodebInfo {
 524         pipInd := bytes.IndexByte(payload, '|')
 525         setupRequest := &models.E2SetupRequestMessage{}
 526         _ = xml.Unmarshal(normalizeXml(payload[pipInd+1:]), &setupRequest.E2APPDU)
 527
 528         nb := *nodeb
 529
 530         if nodeb.NodeType == entities.Node_ENB {
 531                 return &nb
 532         }
 533
 534         if ranFuncs := setupRequest.ExtractRanFunctionsList(); ranFuncs != nil {
 535                 updatedGnb := *nodeb.GetGnb()
 536                 updatedGnb.RanFunctions = ranFuncs
 537                 nb.Configuration =&entities.NodebInfo_Gnb{Gnb: &updatedGnb}
 538         }
 539
 540         return &nb
 541 }
 542
 543 func TestE2SetupRequestNotificationHandler_HandleExistingConnectedEnbSuccess(t *testing.T) {
 544         xmlEnb := readXmlFile(t, EnbSetupRequestXmlPath)
 545         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, ranListManager := initMocks(t)
 546
 547         oldNbIdentity := &entities.NbIdentity{InventoryName: enbNodebRanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 548         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{oldNbIdentity}, nil)
 549
 550         err := ranListManager.InitNbIdentityMap()
 551         if err != nil {
 552                 t.Errorf("Error cannot init identity")
 553         }
 554         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 555         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 556         var nodebInfo = &entities.NodebInfo{
 557                 RanName:                      enbNodebRanName,
 558                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 559                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 560                 NodeType:                     entities.Node_ENB,
 561                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{}},
 562         }
 563
 564         readerMock.On("GetNodeb", enbNodebRanName).Return(nodebInfo, nil)
 565         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 566
 567         notificationRequest := &models.NotificationRequest{RanName: enbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlEnb...)}
 568         enbToUpdate := getExpectedNodebForExistingRan(nodebInfo, notificationRequest.Payload)
 569         enbToUpdate.SetupFromNetwork = true
 570         newNbIdentity := &entities.NbIdentity{InventoryName: enbNodebRanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 571         writerMock.On("UpdateNbIdentities", enbToUpdate.GetNodeType(), []*entities.NbIdentity{oldNbIdentity}, []*entities.NbIdentity{newNbIdentity}).Return(nil)
 572         writerMock.On("UpdateNodebInfo", enbToUpdate).Return(nil)
 573         e2tInstancesManagerMock.On("AddRansToInstance", e2tInstanceFullAddress, []string{enbNodebRanName}).Return(nil)
 574         var errEmpty error
 575         rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(&rmrCgo.MBuf{}, errEmpty)
 576         handler.Handle(notificationRequest)
 577         readerMock.AssertExpectations(t)
 578         writerMock.AssertExpectations(t)
 579         e2tInstancesManagerMock.AssertExpectations(t)
 580         rmrMessengerMock.AssertCalled(t, "SendMsg", mock.Anything, true)
 581 }
 582
 583 func TestE2SetupRequestNotificationHandler_HandleExistingDisconnectedEnbSuccess(t *testing.T) {
 584         xmlEnb := readXmlFile(t, EnbSetupRequestXmlPath)
 585         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, ranListManager := initMocks(t)
 586
 587         oldNbIdentity := &entities.NbIdentity{InventoryName: enbNodebRanName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 588         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{oldNbIdentity}, nil)
 589         err := ranListManager.InitNbIdentityMap()
 590         if err != nil {
 591                 t.Errorf("Error cannot init identity")
 592         }
 593
 594         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 595         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 596         var nodebInfo = &entities.NodebInfo{
 597                 RanName:                      enbNodebRanName,
 598                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 599                 ConnectionStatus:             entities.ConnectionStatus_DISCONNECTED,
 600                 NodeType:                     entities.Node_ENB,
 601                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{}},
 602         }
 603
 604         readerMock.On("GetNodeb", enbNodebRanName).Return(nodebInfo, nil)
 605         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 606
 607         notificationRequest := &models.NotificationRequest{RanName: enbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlEnb...)}
 608         enbToUpdate := getExpectedNodebForExistingRan(nodebInfo, notificationRequest.Payload)
 609
 610         enbToUpdate2 := *enbToUpdate
 611         enbToUpdate2.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 612         enbToUpdate2.SetupFromNetwork = true
 613         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &enbToUpdate2, enbNodebRanName+"_CONNECTED").Return(nil)
 614
 615         newNbIdentity := &entities.NbIdentity{InventoryName: enbNodebRanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 616         writerMock.On("UpdateNbIdentities", enbToUpdate.GetNodeType(), []*entities.NbIdentity{oldNbIdentity}, []*entities.NbIdentity{newNbIdentity}).Return(nil)
 617
 618         enbToUpdate3 := *enbToUpdate
 619         enbToUpdate3.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 620         enbToUpdate3.SetupFromNetwork = true
 621         enbToUpdate3.AssociatedE2TInstanceAddress = e2tInstanceFullAddress
 622         writerMock.On("UpdateNodebInfo", &enbToUpdate3).Return(nil)
 623         e2tInstancesManagerMock.On("AddRansToInstance", e2tInstanceFullAddress, []string{enbNodebRanName}).Return(nil)
 624         var errEmpty error
 625         rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(&rmrCgo.MBuf{}, errEmpty)
 626         handler.Handle(notificationRequest)
 627         readerMock.AssertExpectations(t)
 628         writerMock.AssertExpectations(t)
 629         e2tInstancesManagerMock.AssertExpectations(t)
 630         rmrMessengerMock.AssertCalled(t, "SendMsg", mock.Anything, true)
 631 }
 632
 633 func testE2SetupRequestNotificationHandler_HandleExistingConnectedGnbSuccess(t *testing.T, withFunctions bool, xmlToRead string) {
 634         xmlGnb := readXmlFile(t, xmlToRead)
 635         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, ranListManager := initMocks(t)
 636
 637         oldNbIdentity := &entities.NbIdentity{InventoryName: gnbNodebRanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 638         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{oldNbIdentity}, nil)
 639         err := ranListManager.InitNbIdentityMap()
 640         if err != nil {
 641                 t.Errorf("Error cannot init identity")
 642         }
 643
 644         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 645         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 646         var nodebInfo = &entities.NodebInfo{
 647                 RanName:                      gnbNodebRanName,
 648                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 649                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 650                 NodeType:                     entities.Node_GNB,
 651                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
 652         }
 653
 654         if withFunctions {
 655                 gnb := nodebInfo.GetGnb()
 656                 gnb.RanFunctions = []*entities.RanFunction{{RanFunctionId: 2, RanFunctionRevision: 2}}
 657         }
 658
 659         readerMock.On("GetNodeb", gnbNodebRanName).Return(nodebInfo, nil)
 660         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 661
 662         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 663         gnbToUpdate := getExpectedNodebForExistingRan(nodebInfo, notificationRequest.Payload)
 664         gnbToUpdate.SetupFromNetwork = true
 665         writerMock.On("UpdateNodebInfo", gnbToUpdate).Return(nil)
 666         if withFunctions {
 667                 writerMock.On("UpdateNodebInfoAndPublish", gnbToUpdate).Return(nil)
 668         }
 669         newNbIdentity := &entities.NbIdentity{InventoryName: gnbNodebRanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 670         writerMock.On("UpdateNbIdentities", gnbToUpdate.GetNodeType(), []*entities.NbIdentity{oldNbIdentity}, []*entities.NbIdentity{newNbIdentity}).Return(nil)
 671
 672         e2tInstancesManagerMock.On("AddRansToInstance", e2tInstanceFullAddress, []string{gnbNodebRanName}).Return(nil)
 673         var errEmpty error
 674         rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(&rmrCgo.MBuf{}, errEmpty)
 675         handler.Handle(notificationRequest)
 676         readerMock.AssertExpectations(t)
 677         writerMock.AssertExpectations(t)
 678         e2tInstancesManagerMock.AssertExpectations(t)
 679         rmrMessengerMock.AssertCalled(t, "SendMsg", mock.Anything, true)
 680 }
 681
 682 func TestE2SetupRequestNotificationHandler_HandleExistingConnectedGnbRoutingManagerError(t *testing.T) {
 683         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 684         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, ranListManager := initMocks(t)
 685         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 686         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 687         var nodebInfo = &entities.NodebInfo{
 688                 RanName:                      gnbNodebRanName,
 689                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 690                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 691                 NodeType:                     entities.Node_GNB,
 692                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
 693         }
 694         oldNbIdentity := &entities.NbIdentity{InventoryName: gnbNodebRanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 695         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{oldNbIdentity}, nil)
 696         err := ranListManager.InitNbIdentityMap()
 697         if err != nil {
 698                 t.Errorf("Error cannot init identity")
 699         }
 700
 701         gnb := nodebInfo.GetGnb()
 702         gnb.RanFunctions = []*entities.RanFunction{{RanFunctionId: 2, RanFunctionRevision: 2}}
 703
 704         readerMock.On("GetNodeb", gnbNodebRanName).Return(nodebInfo, nil)
 705         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(errors.New("association error"))
 706
 707         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 708         gnbToUpdate := getExpectedNodebForExistingRan(nodebInfo, notificationRequest.Payload)
 709
 710         gnbToUpdate2 := *gnbToUpdate
 711         gnbToUpdate2.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
 712         gnbToUpdate2.SetupFromNetwork = true
 713         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &gnbToUpdate2, gnbNodebRanName+"_DISCONNECTED").Return(nil)
 714
 715         newNbIdentity := &entities.NbIdentity{InventoryName: gnbNodebRanName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 716         writerMock.On("UpdateNbIdentities", gnbToUpdate2.GetNodeType(), []*entities.NbIdentity{oldNbIdentity}, []*entities.NbIdentity{newNbIdentity}).Return(nil)
 717         var errEmpty error
 718         rmrMessengerMock.On("WhSendMsg", mock.Anything, true).Return(&rmrCgo.MBuf{}, errEmpty)
 719         handler.Handle(notificationRequest)
 720         readerMock.AssertExpectations(t)
 721         writerMock.AssertExpectations(t)
 722         e2tInstancesManagerMock.AssertExpectations(t)
 723         rmrMessengerMock.AssertCalled(t, "WhSendMsg", mock.Anything, true)
 724 }
 725
 726 func TestE2SetupRequestNotificationHandler_HandleExistingGnbInvalidConnectionStatusError(t *testing.T) {
 727         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 728         handler, readerMock, writerMock, _, e2tInstancesManagerMock, rmrMessengerMock, _ := initMocks(t)
 729         var gnb = &entities.NodebInfo{RanName: gnbNodebRanName, ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 730         readerMock.On("GetNodeb", gnbNodebRanName).Return(gnb, nil)
 731         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 732         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 733         prefBytes := []byte(e2SetupMsgPrefix)
 734         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append(prefBytes, xmlGnb...)}
 735         handler.Handle(notificationRequest)
 736         readerMock.AssertExpectations(t)
 737         writerMock.AssertExpectations(t)
 738         e2tInstancesManagerMock.AssertExpectations(t)
 739         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 740 }
 741
 742 func TestE2SetupRequestNotificationHandler_HandleExistingConnectedGnbWithoutFunctionsSuccess(t *testing.T) {
 743         testE2SetupRequestNotificationHandler_HandleExistingConnectedGnbSuccess(t, false, GnbWithoutFunctionsSetupRequestXmlPath)
 744 }
 745
 746 func TestE2SetupRequestNotificationHandler_HandleExistingConnectedGnbWithFunctionsSuccess(t *testing.T) {
 747         testE2SetupRequestNotificationHandler_HandleExistingConnectedGnbSuccess(t, true, GnbSetupRequestXmlPath)
 748 }
 749
 750 func TestE2SetupRequestNotificationHandler_HandleExistingConnectedGnbWithZeroFunctionsSuccess(t *testing.T) {
 751         testE2SetupRequestNotificationHandler_HandleExistingConnectedGnbSuccess(t, true, GnbWithZeroFunctionsSetupRequestXmlPath)
 752 }
 753
 754 func TestE2SetupRequestNotificationHandler_HandleExistingDisconnectedGnbSuccess(t *testing.T) {
 755         xmlGnb := readXmlFile(t, GnbSetupRequestXmlPath)
 756         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, ranListManager := initMocks(t)
 757         oldNbIdentity := &entities.NbIdentity{InventoryName: gnbNodebRanName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 758         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{oldNbIdentity}, nil)
 759         err := ranListManager.InitNbIdentityMap()
 760         if err != nil {
 761                 t.Errorf("Error cannot init identity")
 762         }
 763
 764         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 765         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 766         var nodebInfo = &entities.NodebInfo{
 767                 RanName:                      gnbNodebRanName,
 768                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 769                 ConnectionStatus:             entities.ConnectionStatus_DISCONNECTED,
 770                 NodeType:                     entities.Node_GNB,
 771                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
 772         }
 773
 774         readerMock.On("GetNodeb", gnbNodebRanName).Return(nodebInfo, nil)
 775         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 776
 777         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 778         gnbToUpdate := getExpectedNodebForExistingRan(nodebInfo, notificationRequest.Payload)
 779         gnbToUpdate2 := *gnbToUpdate
 780         gnbToUpdate2.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 781         gnbToUpdate2.SetupFromNetwork = true
 782         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &gnbToUpdate2, gnbNodebRanName+"_CONNECTED").Return(nil)
 783         gnbToUpdate3 := *gnbToUpdate
 784         gnbToUpdate3.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 785         gnbToUpdate3.SetupFromNetwork = true
 786         gnbToUpdate3.AssociatedE2TInstanceAddress = e2tInstanceFullAddress
 787         writerMock.On("UpdateNodebInfo", &gnbToUpdate3).Return(nil)
 788
 789         newNbIdentity := &entities.NbIdentity{InventoryName: gnbNodebRanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 790         writerMock.On("UpdateNbIdentities", gnbToUpdate3.GetNodeType(), []*entities.NbIdentity{oldNbIdentity}, []*entities.NbIdentity{newNbIdentity}).Return(nil)
 791
 792         e2tInstancesManagerMock.On("AddRansToInstance", e2tInstanceFullAddress, []string{gnbNodebRanName}).Return(nil)
 793         var errEmpty error
 794         rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(&rmrCgo.MBuf{}, errEmpty)
 795         handler.Handle(notificationRequest)
 796         readerMock.AssertExpectations(t)
 797         writerMock.AssertExpectations(t)
 798         e2tInstancesManagerMock.AssertExpectations(t)
 799 }
 800
 801 /* Existing Ran UTs - END */