E2Manager/handlers/rmrmsghandlers/e2_setup_request_notification_handler_test.go

   1 //
   2 // Copyright 2019 AT&T Intellectual Property
   3 // Copyright 2019 Nokia
   4 // Copyright (c) 2022 Samsung Electronics Co., Ltd. All Rights Reserved.
   5 // Copyright 2023 Capgemini
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18
  19 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
  20 //  platform project (RICP).
  21
  22 package rmrmsghandlers
  23
  24 import (
  25         "bytes"
  26         "e2mgr/configuration"
  27         "e2mgr/managers"
  28         "e2mgr/mocks"
  29         "e2mgr/models"
  30         "e2mgr/rmrCgo"
  31         "e2mgr/services"
  32         "e2mgr/tests"
  33         "e2mgr/utils"
  34         "encoding/xml"
  35         "errors"
  36         "testing"
  37
  38         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  39         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  40         "github.com/stretchr/testify/assert"
  41         "github.com/stretchr/testify/mock"
  42 )
  43
  44 const (
  45         e2tInstanceFullAddress                   = "10.0.2.15:9999"
  46         e2SetupMsgPrefix                         = e2tInstanceFullAddress + "|"
  47         gnbNodebRanName                          = "gnb:310-410-b5c67788"
  48         enbNodebRanName                          = "enB_macro:P310-410-b5c67788"
  49         GnbSetupRequestXmlPath                   = "../../tests/resources/setupRequest/setupRequest_gnb.xml"
  50         GnbWithZeroFunctionsSetupRequestXmlPath  = "../../tests/resources/setupRequest/setupRequest_gnb_with_zero_functions.xml"
  51         EnGnbSetupRequestXmlPath                 = "../../tests/resources/setupRequest/setupRequest_en-gNB.xml"
  52         NgEnbSetupRequestXmlPath                 = "../../tests/resources/setupRequest/setupRequest_ng-eNB.xml"
  53         EnbSetupRequestXmlPath                   = "../../tests/resources/setupRequest/setupRequest_enb.xml"
  54         GnbWithoutFunctionsSetupRequestXmlPath   = "../../tests/resources/setupRequest/setupRequest_gnb_without_functions.xml"
  55         E2SetupFailureResponseWithMiscCause      = "<E2AP-PDU><unsuccessfulOutcome><procedureCode>1</procedureCode><criticality><reject/></criticality><value><E2setupFailure><protocolIEs><E2setupFailureIEs><id>49</id><criticality><ignore/></criticality><value><TransactionID>1</TransactionID></value></E2setupFailureIEs><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>"
  56         E2SetupFailureResponseWithTransportCause = "<E2AP-PDU><unsuccessfulOutcome><procedureCode>1</procedureCode><criticality><reject/></criticality><value><E2setupFailure><protocolIEs><E2setupFailureIEs><id>49</id><criticality><ignore/></criticality><value><TransactionID>1</TransactionID></value></E2setupFailureIEs><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>"
  57         E2SetupFailureResponseWithRicCause       = "<E2AP-PDU><unsuccessfulOutcome><procedureCode>1</procedureCode><criticality><reject/></criticality><value><E2setupFailure><protocolIEs><E2setupFailureIEs><id>49</id><criticality><ignore/></criticality><value><TransactionID>1</TransactionID></value></E2setupFailureIEs><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>"
  58         StateChangeMessageChannel                = "RAN_CONNECTION_STATUS_CHANGE"
  59 )
  60
  61 func initMocks(t *testing.T) (*E2SetupRequestNotificationHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock, *mocks.RoutingManagerClientMock, managers.RanListManager) {
  62         logger := tests.InitLog(t)
  63         config := &configuration.Configuration{
  64                 RnibRetryIntervalMs:       10,
  65                 MaxRnibConnectionAttempts: 3,
  66                 RnibWriter: configuration.RnibWriterConfig{
  67                         StateChangeMessageChannel: StateChangeMessageChannel,
  68                 },
  69                 GlobalRicId: struct {
  70                         RicId string
  71                         Mcc   string
  72                         Mnc   string
  73                 }{Mcc: "327", Mnc: "94", RicId: "AACCE"}}
  74         rmrMessengerMock := &mocks.RmrMessengerMock{}
  75         rmrSender := tests.InitRmrSender(rmrMessengerMock, logger)
  76         readerMock := &mocks.RnibReaderMock{}
  77         writerMock := &mocks.RnibWriterMock{}
  78         routingManagerClientMock := &mocks.RoutingManagerClientMock{}
  79         rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
  80         e2tInstancesManagerMock := &mocks.E2TInstancesManagerMock{}
  81         ranListManager := managers.NewRanListManager(logger, rnibDataService)
  82         ranAlarmService := services.NewRanAlarmService(logger, config)
  83         ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService, ranListManager, ranAlarmService)
  84         e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManagerMock, routingManagerClientMock, ranConnectStatusChangeManager)
  85         handler := NewE2SetupRequestNotificationHandler(logger, config, e2tInstancesManagerMock, rmrSender, rnibDataService, e2tAssociationManager, ranConnectStatusChangeManager, ranListManager)
  86         return handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, ranListManager
  87 }
  88
  89 func getMbuf(ranName string, msgType int, payloadStr string, request *models.NotificationRequest) *rmrCgo.MBuf {
  90         payload := []byte(payloadStr)
  91         mbuf := rmrCgo.NewMBuf(msgType, len(payload), ranName, &payload, &request.TransactionId, request.GetMsgSrc())
  92         return mbuf
  93 }
  94
  95 func TestParseGnbSetupRequest_Success(t *testing.T) {
  96         xmlGnb := utils.ReadXmlFile(t, GnbSetupRequestXmlPath)
  97         handler, _, _, _, _, _, _ := initMocks(t)
  98         prefBytes := []byte(e2SetupMsgPrefix)
  99         request, _, err := handler.parseSetupRequest(append(prefBytes, xmlGnb...))
 100         assert.Equal(t, "02F829", request.GetPlmnId())
 101         assert.Equal(t, "001100000011000000110000", request.GetNbId())
 102         assert.Nil(t, err)
 103 }
 104
 105 func TestParseEnGnbSetupRequest_Success(t *testing.T) {
 106         enGnbXml := utils.ReadXmlFile(t, EnGnbSetupRequestXmlPath)
 107         handler, _, _, _, _, _, _ := initMocks(t)
 108         prefBytes := []byte(e2SetupMsgPrefix)
 109         request, _, err := handler.parseSetupRequest(append(prefBytes, enGnbXml...))
 110         assert.Equal(t, "131014", request.GetPlmnId())
 111         assert.Equal(t, "11000101110001101100011111111000", request.GetNbId())
 112         assert.Nil(t, err)
 113 }
 114
 115 func TestParseNgEnbSetupRequest_Success(t *testing.T) {
 116         ngEnbXml := utils.ReadXmlFile(t, NgEnbSetupRequestXmlPath)
 117         handler, _, _, _, _, _, _ := initMocks(t)
 118         prefBytes := []byte(e2SetupMsgPrefix)
 119         request, _, err := handler.parseSetupRequest(append(prefBytes, ngEnbXml...))
 120         assert.Equal(t, "131014", request.GetPlmnId())
 121         assert.Equal(t, "101010101010101010", request.GetNbId())
 122         assert.Nil(t, err)
 123 }
 124
 125 func TestParseEnbSetupRequest_Success(t *testing.T) {
 126         enbXml := utils.ReadXmlFile(t, EnbSetupRequestXmlPath)
 127         handler, _, _, _, _, _, _ := initMocks(t)
 128         prefBytes := []byte(e2SetupMsgPrefix)
 129         request, _, err := handler.parseSetupRequest(append(prefBytes, enbXml...))
 130         assert.Equal(t, "6359AB", request.GetPlmnId())
 131         assert.Equal(t, "101010101010101010", request.GetNbId())
 132         assert.Nil(t, err)
 133 }
 134
 135 func TestParseSetupRequest_PipFailure(t *testing.T) {
 136         xmlGnb := utils.ReadXmlFile(t, GnbSetupRequestXmlPath)
 137         handler, _, _, _, _, _, _ := initMocks(t)
 138         prefBytes := []byte("10.0.2.15:9999")
 139         request, _, err := handler.parseSetupRequest(append(prefBytes, xmlGnb...))
 140         assert.Nil(t, request)
 141         assert.NotNil(t, err)
 142         assert.EqualError(t, err, "#E2SetupRequestNotificationHandler.parseSetupRequest - Error parsing E2 Setup Request failed extract Payload: no | separator found")
 143 }
 144
 145 func TestParseSetupRequest_UnmarshalFailure(t *testing.T) {
 146         handler, _, _, _, _, _, _ := initMocks(t)
 147         prefBytes := []byte(e2SetupMsgPrefix)
 148         request, _, err := handler.parseSetupRequest(append(prefBytes, 1, 2, 3))
 149         assert.Nil(t, request)
 150         assert.NotNil(t, err)
 151         assert.EqualError(t, err, "#E2SetupRequestNotificationHandler.parseSetupRequest - Error unmarshalling E2 Setup Request payload: 31302e302e322e31353a393939397c010203")
 152 }
 153
 154 func TestE2SetupRequestNotificationHandler_HandleParseError(t *testing.T) {
 155         xmlGnb := utils.ReadXmlFile(t, GnbSetupRequestXmlPath)
 156         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, _ := initMocks(t)
 157         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 158         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte("invalid_prefix"), xmlGnb...)}
 159         handler.Handle(notificationRequest)
 160         readerMock.AssertNotCalled(t, "GetNodeb", mock.Anything)
 161         writerMock.AssertNotCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
 162         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 163         writerMock.AssertNotCalled(t, "UpdateNodebInfo", mock.Anything)
 164         e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
 165         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 166 }
 167
 168 func TestE2SetupRequestNotificationHandler_HandleUnmarshalError(t *testing.T) {
 169         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, _ := initMocks(t)
 170         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 171         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), "xmlGnb"...)}
 172         handler.Handle(notificationRequest)
 173         readerMock.AssertNotCalled(t, "GetNodeb", mock.Anything)
 174         writerMock.AssertNotCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
 175         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 176         writerMock.AssertNotCalled(t, "UpdateNodebInfo", mock.Anything)
 177         e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
 178         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 179 }
 180
 181 func TestE2SetupRequestNotificationHandler_ConvertTo20BitStringError(t *testing.T) {
 182         xmlEnGnb := utils.ReadXmlFile(t, EnGnbSetupRequestXmlPath)
 183         logger := tests.InitLog(t)
 184         config := &configuration.Configuration{
 185                 RnibRetryIntervalMs:       10,
 186                 MaxRnibConnectionAttempts: 3,
 187                 RnibWriter: configuration.RnibWriterConfig{
 188                         StateChangeMessageChannel: StateChangeMessageChannel,
 189                 },
 190                 GlobalRicId: struct {
 191                         RicId string
 192                         Mcc   string
 193                         Mnc   string
 194                 }{Mcc: "327", Mnc: "94", RicId: "10011001101010101011"}}
 195         rmrMessengerMock := &mocks.RmrMessengerMock{}
 196         rmrSender := tests.InitRmrSender(rmrMessengerMock, logger)
 197         readerMock := &mocks.RnibReaderMock{}
 198         writerMock := &mocks.RnibWriterMock{}
 199         routingManagerClientMock := &mocks.RoutingManagerClientMock{}
 200         rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
 201         e2tInstancesManagerMock := &mocks.E2TInstancesManagerMock{}
 202         ranListManager := managers.NewRanListManager(logger, rnibDataService)
 203         ranAlarmService := services.NewRanAlarmService(logger, config)
 204         ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService, ranListManager, ranAlarmService)
 205
 206         e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManagerMock, routingManagerClientMock, ranConnectStatusChangeManager)
 207         handler := NewE2SetupRequestNotificationHandler(logger, config, e2tInstancesManagerMock, rmrSender, rnibDataService, e2tAssociationManager, ranConnectStatusChangeManager, ranListManager)
 208         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 209         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 210         var gnb *entities.NodebInfo
 211         readerMock.On("GetNodeb", mock.Anything).Return(gnb, common.NewResourceNotFoundError("Not found"))
 212         writerMock.On("SaveNodeb", mock.Anything, mock.Anything).Return(nil)
 213         writerMock.On("AddNbIdentity", entities.Node_GNB, mock.Anything).Return(nil)
 214         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", mock.Anything, mock.Anything).Return(nil)
 215         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 216         writerMock.On("UpdateNodebInfo", mock.Anything).Return(nil)
 217         writerMock.On("UpdateNbIdentities", mock.Anything, mock.Anything, mock.Anything).Return(nil)
 218         e2tInstancesManagerMock.On("AddRansToInstance", mock.Anything, mock.Anything).Return(nil)
 219         var errEmpty error
 220         rmrMessage := &rmrCgo.MBuf{}
 221         rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(rmrMessage, errEmpty)
 222         prefBytes := []byte(e2SetupMsgPrefix)
 223         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append(prefBytes, xmlEnGnb...)}
 224         handler.Handle(notificationRequest)
 225         readerMock.AssertCalled(t, "GetNodeb", mock.Anything)
 226         e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceFullAddress)
 227         writerMock.AssertCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
 228         routingManagerClientMock.AssertCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 229         writerMock.AssertCalled(t, "UpdateNodebInfo", mock.Anything)
 230         e2tInstancesManagerMock.AssertCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
 231         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 232 }
 233
 234 func TestExtractionOfNodeTypeFromRanName(t *testing.T) {
 235         handler, _, _, _, _, _, _ := initMocks(t)
 236         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"}
 237         for _, v := range validRanNames {
 238                 nodeb := &entities.NodebInfo{RanName: v}
 239                 err := handler.setNodeTypeAndConfiguration(nodeb)
 240                 assert.Nil(t, err)
 241         }
 242         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"}
 243         for _, v := range inValidRanNames {
 244                 nodeb := &entities.NodebInfo{RanName: v}
 245                 err := handler.setNodeTypeAndConfiguration(nodeb)
 246                 assert.NotNil(t, err, v)
 247         }
 248 }
 249
 250 func TestE2SetupRequestNotificationHandler_GetGeneralConfigurationFailure(t *testing.T) {
 251         xmlGnb := utils.ReadXmlFile(t, GnbSetupRequestXmlPath)
 252         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, _ := initMocks(t)
 253         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{}, common.NewInternalError(errors.New("some error")))
 254         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 255         handler.Handle(notificationRequest)
 256         rmrMessengerMock.AssertNotCalled(t, "SendMsg")
 257         e2tInstancesManagerMock.AssertNotCalled(t, "GetE2TInstance")
 258         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance")
 259         readerMock.AssertNotCalled(t, "GetNodeb")
 260         writerMock.AssertNotCalled(t, "SaveNodeb")
 261 }
 262
 263 func TestE2SetupRequestNotificationHandler_EnableRicFalse(t *testing.T) {
 264         xmlGnb := utils.ReadXmlFile(t, GnbSetupRequestXmlPath)
 265         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, _ := initMocks(t)
 266         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: false}, nil)
 267         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 268         mbuf := getMbuf(gnbNodebRanName, rmrCgo.RIC_E2_SETUP_FAILURE, E2SetupFailureResponseWithMiscCause, notificationRequest)
 269         rmrMessengerMock.On("WhSendMsg", mbuf, true).Return(&rmrCgo.MBuf{}, nil)
 270         handler.Handle(notificationRequest)
 271         rmrMessengerMock.AssertCalled(t, "WhSendMsg", mbuf, true)
 272         e2tInstancesManagerMock.AssertNotCalled(t, "GetE2TInstance")
 273         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance")
 274         readerMock.AssertNotCalled(t, "GetNodeb")
 275         writerMock.AssertNotCalled(t, "SaveNodeb")
 276 }
 277
 278 func TestE2SetupRequestNotificationHandler_HandleGetE2TInstanceError(t *testing.T) {
 279         xmlGnb := utils.ReadXmlFile(t, GnbSetupRequestXmlPath)
 280         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, _ := initMocks(t)
 281         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 282         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, common.NewResourceNotFoundError("Not found"))
 283         prefBytes := []byte(e2SetupMsgPrefix)
 284         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append(prefBytes, xmlGnb...)}
 285         handler.Handle(notificationRequest)
 286         e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceFullAddress)
 287         readerMock.AssertNotCalled(t, "GetNodeb", mock.Anything)
 288         writerMock.AssertNotCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
 289         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 290         writerMock.AssertNotCalled(t, "UpdateNodebInfo", mock.Anything)
 291         e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
 292         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 293 }
 294
 295 func TestE2SetupRequestNotificationHandler_HandleGetNodebError(t *testing.T) {
 296         xmlGnb := utils.ReadXmlFile(t, GnbSetupRequestXmlPath)
 297         handler, readerMock, writerMock, routingManagerClientMock, e2tInstancesManagerMock, rmrMessengerMock, _ := initMocks(t)
 298         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 299         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 300         var gnb *entities.NodebInfo
 301         readerMock.On("GetNodeb", mock.Anything).Return(gnb, common.NewInternalError(errors.New("some error")))
 302         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 303         handler.Handle(notificationRequest)
 304         e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceFullAddress)
 305         readerMock.AssertCalled(t, "GetNodeb", mock.Anything)
 306         writerMock.AssertNotCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
 307         routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 308         writerMock.AssertNotCalled(t, "UpdateNodebInfo", mock.Anything)
 309         e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
 310         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 311 }
 312
 313 /* New Ran UTs - BEGIN */
 314
 315 func TestE2SetupRequestNotificationHandler_HandleNewRanSaveNodebFailure(t *testing.T) {
 316         xml := utils.ReadXmlFile(t, GnbSetupRequestXmlPath)
 317         handler, readerMock, writerMock, _, e2tInstancesManagerMock, _, _ := initMocks(t)
 318         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 319         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 320         var gnb *entities.NodebInfo
 321         readerMock.On("GetNodeb", gnbNodebRanName).Return(gnb, common.NewResourceNotFoundError("Not found"))
 322         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xml...)}
 323         nodebInfo := getExpectedGnbNodebForNewRan(notificationRequest.Payload)
 324         writerMock.On("SaveNodeb", nodebInfo).Return(common.NewInternalError(errors.New("error")))
 325         handler.Handle(notificationRequest)
 326
 327         readerMock.AssertExpectations(t)
 328         writerMock.AssertExpectations(t)
 329         e2tInstancesManagerMock.AssertExpectations(t)
 330 }
 331
 332 func TestE2SetupRequestNotificationHandler_HandleNewRan_invalidRanName(t *testing.T) {
 333         xml := utils.ReadXmlFile(t, EnbSetupRequestXmlPath)
 334         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _, _ := initMocks(t)
 335         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 336         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 337         var enb *entities.NodebInfo
 338         invalidEnbRanName := "enB-macro:P310-410-b5c67788"
 339         readerMock.On("GetNodeb", invalidEnbRanName).Return(enb, common.NewResourceNotFoundError("Not found"))
 340         notificationRequest := &models.NotificationRequest{RanName: invalidEnbRanName, Payload: append([]byte(e2SetupMsgPrefix), xml...)}
 341         mbuf := getMbuf(invalidEnbRanName, rmrCgo.RIC_E2_SETUP_FAILURE, E2SetupFailureResponseWithRicCause, notificationRequest)
 342         rmrMessengerMock.On("WhSendMsg", mbuf, true).Return(&rmrCgo.MBuf{}, nil)
 343         handler.Handle(notificationRequest)
 344
 345         readerMock.AssertExpectations(t)
 346         writerMock.AssertExpectations(t)
 347         rmrMessengerMock.AssertCalled(t, "WhSendMsg", mbuf, true)
 348         e2tInstancesManagerMock.AssertExpectations(t)
 349 }
 350
 351 func TestE2SetupRequestNotificationHandler_HandleNewRanAddNbIdentityFailure(t *testing.T) {
 352         xml := utils.ReadXmlFile(t, GnbSetupRequestXmlPath)
 353         handler, readerMock, writerMock, _, e2tInstancesManagerMock, _, _ := initMocks(t)
 354         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 355         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 356         var gnb *entities.NodebInfo
 357         readerMock.On("GetNodeb", gnbNodebRanName).Return(gnb, common.NewResourceNotFoundError("Not found"))
 358         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xml...)}
 359         nodebInfo := getExpectedGnbNodebForNewRan(notificationRequest.Payload)
 360         writerMock.On("SaveNodeb", nodebInfo).Return(nil)
 361         nbIdentity := &entities.NbIdentity{InventoryName: gnbNodebRanName, GlobalNbId: nodebInfo.GlobalNbId}
 362         writerMock.On("AddNbIdentity", entities.Node_GNB, nbIdentity).Return(common.NewInternalError(errors.New("error")))
 363         handler.Handle(notificationRequest)
 364         readerMock.AssertExpectations(t)
 365         writerMock.AssertExpectations(t)
 366         e2tInstancesManagerMock.AssertExpectations(t)
 367 }
 368
 369 func TestE2SetupRequestNotificationHandler_HandleNewRanRoutingManagerError(t *testing.T) {
 370         xmlGnb := utils.ReadXmlFile(t, GnbSetupRequestXmlPath)
 371
 372         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, _ := initMocks(t)
 373         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 374         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 375         readerMock.On("GetNodeb", gnbNodebRanName).Return(&entities.NodebInfo{}, common.NewResourceNotFoundError("Not found"))
 376         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 377         nodebInfo := getExpectedGnbNodebForNewRan(notificationRequest.Payload)
 378         writerMock.On("SaveNodeb", nodebInfo).Return(nil)
 379         nbIdentity := &entities.NbIdentity{InventoryName: gnbNodebRanName, GlobalNbId: nodebInfo.GlobalNbId}
 380         writerMock.On("AddNbIdentity", entities.Node_GNB, nbIdentity).Return(nil)
 381         updatedNodebInfo := *nodebInfo
 382         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(errors.New("association error"))
 383         updatedNodebInfo.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
 384         writerMock.On("UpdateNodebInfo", mock.Anything).Return(nil)
 385         writerMock.On("UpdateNbIdentities", mock.Anything, mock.Anything, mock.Anything).Return(nil)
 386         var errEmpty error
 387         mbuf := getMbuf(gnbNodebRanName, rmrCgo.RIC_E2_SETUP_FAILURE, E2SetupFailureResponseWithTransportCause, notificationRequest)
 388         rmrMessengerMock.On("WhSendMsg", mbuf, true).Return(&rmrCgo.MBuf{}, errEmpty)
 389         handler.Handle(notificationRequest)
 390         readerMock.AssertExpectations(t)
 391         e2tInstancesManagerMock.AssertExpectations(t)
 392         writerMock.AssertExpectations(t)
 393         routingManagerClientMock.AssertCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
 394         e2tInstancesManagerMock.AssertExpectations(t)
 395         rmrMessengerMock.AssertCalled(t, "WhSendMsg", mbuf, true)
 396 }
 397
 398 func testE2SetupRequestNotificationHandler_HandleNewRanSuccess(t *testing.T, xmlPath string, nodeType entities.Node_Type) {
 399         xml := utils.ReadXmlFile(t, xmlPath)
 400         var ranName string
 401         if nodeType == entities.Node_GNB {
 402                 ranName = gnbNodebRanName
 403         } else {
 404                 ranName = enbNodebRanName
 405         }
 406         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, _ := initMocks(t)
 407         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 408         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 409         var gnb *entities.NodebInfo
 410         readerMock.On("GetNodeb", ranName).Return(gnb, common.NewResourceNotFoundError("Not found"))
 411         notificationRequest := &models.NotificationRequest{RanName: ranName, Payload: append([]byte(e2SetupMsgPrefix), xml...)}
 412         var expectedNodebInfo *entities.NodebInfo
 413         if nodeType == entities.Node_GNB {
 414                 expectedNodebInfo = getExpectedGnbNodebForNewRan(notificationRequest.Payload)
 415         } else {
 416                 expectedNodebInfo = getExpectedEnbNodebForNewRan(notificationRequest.Payload)
 417         }
 418         writerMock.On("SaveNodeb", expectedNodebInfo).Return(nil)
 419         nbIdentity := &entities.NbIdentity{InventoryName: ranName, GlobalNbId: expectedNodebInfo.GlobalNbId}
 420         writerMock.On("AddNbIdentity", nodeType, nbIdentity).Return(nil)
 421         updatedNodebInfo := *expectedNodebInfo
 422         updatedNodebInfo.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 423         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", mock.Anything, ranName+"_CONNECTED").Return(nil)
 424         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 425         updatedNodebInfo2 := *expectedNodebInfo
 426         updatedNodebInfo2.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 427         updatedNodebInfo2.AssociatedE2TInstanceAddress = e2tInstanceFullAddress
 428         writerMock.On("UpdateNodebInfo", mock.Anything).Return(nil)
 429
 430         newNbIdentity := &entities.NbIdentity{InventoryName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: expectedNodebInfo.GlobalNbId}
 431         writerMock.On("UpdateNbIdentities", updatedNodebInfo2.GetNodeType(), []*entities.NbIdentity{nbIdentity}, []*entities.NbIdentity{newNbIdentity}).Return(nil)
 432
 433         e2tInstancesManagerMock.On("AddRansToInstance", e2tInstanceFullAddress, []string{ranName}).Return(nil)
 434         rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(&rmrCgo.MBuf{}, nil)
 435
 436         handler.Handle(notificationRequest)
 437
 438         readerMock.AssertExpectations(t)
 439         writerMock.AssertExpectations(t)
 440         e2tInstancesManagerMock.AssertExpectations(t)
 441 }
 442
 443 func TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess(t *testing.T) {
 444         testE2SetupRequestNotificationHandler_HandleNewRanSuccess(t, GnbSetupRequestXmlPath, entities.Node_GNB)
 445 }
 446
 447 func TestE2SetupRequestNotificationHandler_HandleNewGnbWithoutFunctionsSuccess(t *testing.T) {
 448         testE2SetupRequestNotificationHandler_HandleNewRanSuccess(t, GnbWithoutFunctionsSetupRequestXmlPath, entities.Node_GNB)
 449 }
 450
 451 func TestE2SetupRequestNotificationHandler_HandleNewEnGnbSuccess(t *testing.T) {
 452         testE2SetupRequestNotificationHandler_HandleNewRanSuccess(t, EnGnbSetupRequestXmlPath, entities.Node_GNB)
 453 }
 454
 455 func TestE2SetupRequestNotificationHandler_HandleNewNgEnbSuccess(t *testing.T) {
 456         testE2SetupRequestNotificationHandler_HandleNewRanSuccess(t, NgEnbSetupRequestXmlPath, entities.Node_ENB)
 457 }
 458
 459 func getExpectedGnbNodebForNewRan(payload []byte) *entities.NodebInfo {
 460         pipInd := bytes.IndexByte(payload, '|')
 461         setupRequest := &models.E2SetupRequestMessage{}
 462         _ = xml.Unmarshal(utils.NormalizeXml(payload[pipInd+1:]), &setupRequest.E2APPDU)
 463         gnbNodetype := "gNB_CU_UP"
 464         if setupRequest.GetCuupId() != "" && setupRequest.GetCuupId() != "0" && setupRequest.GetDuId() != "" && setupRequest.GetDuId() != "0" {
 465                 gnbNodetype = "gNB_CU_UP"
 466         } else if setupRequest.GetCuupId() != "" && setupRequest.GetCuupId() != "0" {
 467                 gnbNodetype = "gNB_CU_UP"
 468         } else if setupRequest.GetDuId() != "" && setupRequest.GetDuId() != "0" {
 469                 gnbNodetype = "gNB_DU"
 470         }
 471
 472         nodeb := &entities.NodebInfo{
 473                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 474                 RanName:                      gnbNodebRanName,
 475                 SetupFromNetwork:             true,
 476                 NodeType:                     entities.Node_GNB,
 477                 GnbNodeType:                  gnbNodetype,
 478                 Configuration: &entities.NodebInfo_Gnb{
 479                         Gnb: &entities.Gnb{
 480                                 GnbType:      entities.GnbType_GNB,
 481                                 RanFunctions: setupRequest.ExtractRanFunctionsList(),
 482                                 NodeConfigs:  setupRequest.ExtractE2NodeConfigList(),
 483                         },
 484                 },
 485                 GlobalNbId: &entities.GlobalNbId{
 486                         PlmnId: setupRequest.GetPlmnId(),
 487                         NbId:   setupRequest.GetNbId(),
 488                 },
 489                 CuUpId:  setupRequest.GetCuupId(),
 490                 DuId:    setupRequest.GetDuId(),
 491         }
 492
 493         return nodeb
 494 }
 495
 496 func getExpectedEnbNodebForNewRan(payload []byte) *entities.NodebInfo {
 497         pipInd := bytes.IndexByte(payload, '|')
 498         setupRequest := &models.E2SetupRequestMessage{}
 499         _ = xml.Unmarshal(utils.NormalizeXml(payload[pipInd+1:]), &setupRequest.E2APPDU)
 500
 501         nodeb := &entities.NodebInfo{
 502                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 503                 RanName:                      enbNodebRanName,
 504                 SetupFromNetwork:             true,
 505                 NodeType:                     entities.Node_ENB,
 506                 Configuration: &entities.NodebInfo_Enb{
 507                         Enb: &entities.Enb{
 508                                 EnbType:     entities.EnbType_MACRO_ENB,
 509                                 NodeConfigs: setupRequest.ExtractE2NodeConfigList(),
 510                         },
 511                 },
 512                 GlobalNbId: &entities.GlobalNbId{
 513                         PlmnId: setupRequest.GetPlmnId(),
 514                         NbId:   setupRequest.GetNbId(),
 515                 },
 516         }
 517
 518         return nodeb
 519 }
 520
 521 /* New Ran UTs - END */
 522
 523 /* Existing Ran UTs - BEGIN */
 524
 525 func getExpectedNodebForExistingRan(nodeb *entities.NodebInfo, payload []byte) *entities.NodebInfo {
 526         pipInd := bytes.IndexByte(payload, '|')
 527         setupRequest := &models.E2SetupRequestMessage{}
 528         _ = xml.Unmarshal(utils.NormalizeXml(payload[pipInd+1:]), &setupRequest.E2APPDU)
 529
 530         nb := *nodeb
 531
 532         if nodeb.NodeType == entities.Node_ENB {
 533                 if e2NodeConfig := setupRequest.ExtractE2NodeConfigList(); e2NodeConfig != nil {
 534                         updatedEnb := *nodeb.GetEnb()
 535                         updatedEnb.NodeConfigs = e2NodeConfig
 536                         nb.Configuration = &entities.NodebInfo_Enb{Enb: &updatedEnb}
 537                 }
 538
 539                 return &nb
 540         }
 541
 542         if ranFuncs := setupRequest.ExtractRanFunctionsList(); ranFuncs != nil {
 543                 updatedGnb := *nodeb.GetGnb()
 544                 updatedGnb.RanFunctions = ranFuncs
 545                 nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &updatedGnb}
 546         }
 547
 548         if e2NodeConfig := setupRequest.ExtractE2NodeConfigList(); e2NodeConfig != nil {
 549                 updatedGnb := *nodeb.GetGnb()
 550                 updatedGnb.RanFunctions = nb.GetGnb().RanFunctions
 551                 updatedGnb.NodeConfigs = e2NodeConfig
 552                 nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &updatedGnb}
 553         }
 554
 555         return &nb
 556 }
 557
 558 func TestE2SetupRequestNotificationHandler_HandleExistingConnectedEnbSuccess(t *testing.T) {
 559         xmlEnb := utils.ReadXmlFile(t, EnbSetupRequestXmlPath)
 560         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, ranListManager := initMocks(t)
 561
 562         oldNbIdentity := &entities.NbIdentity{InventoryName: enbNodebRanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 563         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{oldNbIdentity}, nil)
 564
 565         err := ranListManager.InitNbIdentityMap()
 566         if err != nil {
 567                 t.Errorf("Error cannot init identity")
 568         }
 569         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 570         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 571         var nodebInfo = &entities.NodebInfo{
 572                 RanName:                      enbNodebRanName,
 573                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 574                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 575                 NodeType:                     entities.Node_ENB,
 576                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{}},
 577         }
 578
 579         readerMock.On("GetNodeb", enbNodebRanName).Return(nodebInfo, nil)
 580         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 581
 582         notificationRequest := &models.NotificationRequest{RanName: enbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlEnb...)}
 583         enbToUpdate := getExpectedNodebForExistingRan(nodebInfo, notificationRequest.Payload)
 584         enbToUpdate.SetupFromNetwork = true
 585         newNbIdentity := &entities.NbIdentity{InventoryName: enbNodebRanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 586         writerMock.On("UpdateNbIdentities", enbToUpdate.GetNodeType(), []*entities.NbIdentity{oldNbIdentity}, []*entities.NbIdentity{newNbIdentity}).Return(nil)
 587         writerMock.On("UpdateNodebInfo", mock.Anything).Return(nil)
 588         e2tInstancesManagerMock.On("AddRansToInstance", e2tInstanceFullAddress, []string{enbNodebRanName}).Return(nil)
 589         var errEmpty error
 590         rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(&rmrCgo.MBuf{}, errEmpty)
 591         handler.Handle(notificationRequest)
 592         readerMock.AssertExpectations(t)
 593         writerMock.AssertExpectations(t)
 594         e2tInstancesManagerMock.AssertExpectations(t)
 595         rmrMessengerMock.AssertCalled(t, "SendMsg", mock.Anything, true)
 596 }
 597
 598 func TestE2SetupRequestNotificationHandler_HandleExistingDisconnectedEnbSuccess(t *testing.T) {
 599         xmlEnb := utils.ReadXmlFile(t, EnbSetupRequestXmlPath)
 600         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, ranListManager := initMocks(t)
 601
 602         oldNbIdentity := &entities.NbIdentity{InventoryName: enbNodebRanName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 603         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{oldNbIdentity}, nil)
 604         err := ranListManager.InitNbIdentityMap()
 605         if err != nil {
 606                 t.Errorf("Error cannot init identity")
 607         }
 608
 609         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 610         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 611         var nodebInfo = &entities.NodebInfo{
 612                 RanName:                      enbNodebRanName,
 613                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 614                 ConnectionStatus:             entities.ConnectionStatus_DISCONNECTED,
 615                 NodeType:                     entities.Node_ENB,
 616                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{}},
 617         }
 618
 619         readerMock.On("GetNodeb", enbNodebRanName).Return(nodebInfo, nil)
 620         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 621
 622         notificationRequest := &models.NotificationRequest{RanName: enbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlEnb...)}
 623         enbToUpdate := getExpectedNodebForExistingRan(nodebInfo, notificationRequest.Payload)
 624
 625         enbToUpdate2 := *enbToUpdate
 626         enbToUpdate2.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 627         enbToUpdate2.SetupFromNetwork = true
 628         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", mock.Anything, enbNodebRanName+"_CONNECTED").Return(nil)
 629
 630         newNbIdentity := &entities.NbIdentity{InventoryName: enbNodebRanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 631         writerMock.On("UpdateNbIdentities", enbToUpdate.GetNodeType(), []*entities.NbIdentity{oldNbIdentity}, []*entities.NbIdentity{newNbIdentity}).Return(nil)
 632
 633         enbToUpdate3 := *enbToUpdate
 634         enbToUpdate3.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 635         enbToUpdate3.SetupFromNetwork = true
 636         enbToUpdate3.AssociatedE2TInstanceAddress = e2tInstanceFullAddress
 637         writerMock.On("UpdateNodebInfo", mock.Anything).Return(nil)
 638         e2tInstancesManagerMock.On("AddRansToInstance", e2tInstanceFullAddress, []string{enbNodebRanName}).Return(nil)
 639         var errEmpty error
 640         rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(&rmrCgo.MBuf{}, errEmpty)
 641         handler.Handle(notificationRequest)
 642         readerMock.AssertExpectations(t)
 643         writerMock.AssertExpectations(t)
 644         e2tInstancesManagerMock.AssertExpectations(t)
 645         rmrMessengerMock.AssertCalled(t, "SendMsg", mock.Anything, true)
 646 }
 647
 648 func testE2SetupRequestNotificationHandler_HandleExistingConnectedGnbSuccess(t *testing.T, withFunctions bool, xmlToRead string) {
 649         xmlGnb := utils.ReadXmlFile(t, xmlToRead)
 650         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, ranListManager := initMocks(t)
 651
 652         oldNbIdentity := &entities.NbIdentity{InventoryName: gnbNodebRanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 653         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{oldNbIdentity}, nil)
 654         err := ranListManager.InitNbIdentityMap()
 655         if err != nil {
 656                 t.Errorf("Error cannot init identity")
 657         }
 658
 659         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 660         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 661         var nodebInfo = &entities.NodebInfo{
 662                 RanName:                      gnbNodebRanName,
 663                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 664                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 665                 NodeType:                     entities.Node_GNB,
 666                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
 667         }
 668
 669         if withFunctions {
 670                 gnb := nodebInfo.GetGnb()
 671                 gnb.RanFunctions = []*entities.RanFunction{{RanFunctionId: 2, RanFunctionRevision: 2}}
 672         }
 673
 674         readerMock.On("GetNodeb", gnbNodebRanName).Return(nodebInfo, nil)
 675         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 676
 677         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 678         gnbToUpdate := getExpectedNodebForExistingRan(nodebInfo, notificationRequest.Payload)
 679         gnbToUpdate.SetupFromNetwork = true
 680         writerMock.On("UpdateNodebInfo", mock.Anything).Return(nil)
 681         if withFunctions {
 682                 writerMock.On("UpdateNodebInfoAndPublish", mock.Anything).Return(nil)
 683         }
 684         newNbIdentity := &entities.NbIdentity{InventoryName: gnbNodebRanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 685         writerMock.On("UpdateNbIdentities", gnbToUpdate.GetNodeType(), []*entities.NbIdentity{oldNbIdentity}, []*entities.NbIdentity{newNbIdentity}).Return(nil)
 686
 687         e2tInstancesManagerMock.On("AddRansToInstance", e2tInstanceFullAddress, []string{gnbNodebRanName}).Return(nil)
 688         var errEmpty error
 689         rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(&rmrCgo.MBuf{}, errEmpty)
 690         handler.Handle(notificationRequest)
 691         readerMock.AssertExpectations(t)
 692         writerMock.AssertExpectations(t)
 693         e2tInstancesManagerMock.AssertExpectations(t)
 694         rmrMessengerMock.AssertCalled(t, "SendMsg", mock.Anything, true)
 695 }
 696
 697 func TestE2SetupRequestNotificationHandler_HandleExistingConnectedGnbRoutingManagerError(t *testing.T) {
 698         xmlGnb := utils.ReadXmlFile(t, GnbSetupRequestXmlPath)
 699         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, ranListManager := initMocks(t)
 700         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 701         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 702         var nodebInfo = &entities.NodebInfo{
 703                 RanName:                      gnbNodebRanName,
 704                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 705                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 706                 NodeType:                     entities.Node_GNB,
 707                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
 708         }
 709         oldNbIdentity := &entities.NbIdentity{InventoryName: gnbNodebRanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 710         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{oldNbIdentity}, nil)
 711         err := ranListManager.InitNbIdentityMap()
 712         if err != nil {
 713                 t.Errorf("Error cannot init identity")
 714         }
 715
 716         gnb := nodebInfo.GetGnb()
 717         gnb.RanFunctions = []*entities.RanFunction{{RanFunctionId: 2, RanFunctionRevision: 2}}
 718         gnb.NodeConfigs = []*entities.E2NodeComponentConfig{{
 719                 E2NodeComponentID: &entities.E2NodeComponentConfig_E2NodeComponentInterfaceTypeNG{
 720                         E2NodeComponentInterfaceTypeNG: &entities.E2NodeComponentInterfaceNG{
 721                                 AmfName: "nginterf",
 722                         },
 723                 },
 724                 E2NodeComponentInterfaceType: entities.E2NodeComponentInterfaceType_ng,
 725                 E2NodeComponentRequestPart:   []byte("72 65 73 70 61 72 74"),
 726                 E2NodeComponentResponsePart:  []byte("72 65 73 70 61 72 74"),
 727         }}
 728
 729         readerMock.On("GetNodeb", gnbNodebRanName).Return(nodebInfo, nil)
 730         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(errors.New("association error"))
 731
 732         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 733         gnbToUpdate := getExpectedNodebForExistingRan(nodebInfo, notificationRequest.Payload)
 734
 735         gnbToUpdate2 := *gnbToUpdate
 736         gnbToUpdate2.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
 737         gnbToUpdate2.SetupFromNetwork = true
 738         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", mock.Anything, gnbNodebRanName+"_DISCONNECTED").Return(nil)
 739
 740         newNbIdentity := &entities.NbIdentity{InventoryName: gnbNodebRanName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 741         writerMock.On("UpdateNbIdentities", gnbToUpdate2.GetNodeType(), []*entities.NbIdentity{oldNbIdentity}, []*entities.NbIdentity{newNbIdentity}).Return(nil)
 742         var errEmpty error
 743         rmrMessengerMock.On("WhSendMsg", mock.Anything, true).Return(&rmrCgo.MBuf{}, errEmpty)
 744         handler.Handle(notificationRequest)
 745         readerMock.AssertExpectations(t)
 746         writerMock.AssertExpectations(t)
 747         e2tInstancesManagerMock.AssertExpectations(t)
 748         rmrMessengerMock.AssertCalled(t, "WhSendMsg", mock.Anything, true)
 749 }
 750
 751 func TestE2SetupRequestNotificationHandler_HandleExistingGnbInvalidConnectionStatusError(t *testing.T) {
 752         xmlGnb := utils.ReadXmlFile(t, GnbSetupRequestXmlPath)
 753         handler, readerMock, writerMock, _, e2tInstancesManagerMock, rmrMessengerMock, _ := initMocks(t)
 754         var gnb = &entities.NodebInfo{RanName: gnbNodebRanName, ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 755         readerMock.On("GetNodeb", gnbNodebRanName).Return(gnb, nil)
 756         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 757         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 758         prefBytes := []byte(e2SetupMsgPrefix)
 759         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append(prefBytes, xmlGnb...)}
 760         handler.Handle(notificationRequest)
 761         readerMock.AssertExpectations(t)
 762         writerMock.AssertExpectations(t)
 763         e2tInstancesManagerMock.AssertExpectations(t)
 764         rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 765 }
 766
 767 func TestE2SetupRequestNotificationHandler_HandleExistingConnectedGnbWithoutFunctionsSuccess(t *testing.T) {
 768         testE2SetupRequestNotificationHandler_HandleExistingConnectedGnbSuccess(t, false, GnbWithoutFunctionsSetupRequestXmlPath)
 769 }
 770
 771 func TestE2SetupRequestNotificationHandler_HandleExistingConnectedGnbWithFunctionsSuccess(t *testing.T) {
 772         testE2SetupRequestNotificationHandler_HandleExistingConnectedGnbSuccess(t, true, GnbSetupRequestXmlPath)
 773 }
 774
 775 func TestE2SetupRequestNotificationHandler_HandleExistingConnectedGnbWithZeroFunctionsSuccess(t *testing.T) {
 776         testE2SetupRequestNotificationHandler_HandleExistingConnectedGnbSuccess(t, true, GnbWithZeroFunctionsSetupRequestXmlPath)
 777 }
 778
 779 func TestE2SetupRequestNotificationHandler_HandleExistingDisconnectedGnbSuccess(t *testing.T) {
 780         xmlGnb := utils.ReadXmlFile(t, GnbSetupRequestXmlPath)
 781         handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock, ranListManager := initMocks(t)
 782         oldNbIdentity := &entities.NbIdentity{InventoryName: gnbNodebRanName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 783         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{oldNbIdentity}, nil)
 784         err := ranListManager.InitNbIdentityMap()
 785         if err != nil {
 786                 t.Errorf("Error cannot init identity")
 787         }
 788
 789         readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
 790         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
 791         var nodebInfo = &entities.NodebInfo{
 792                 RanName:                      gnbNodebRanName,
 793                 AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
 794                 ConnectionStatus:             entities.ConnectionStatus_DISCONNECTED,
 795                 NodeType:                     entities.Node_GNB,
 796                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
 797         }
 798
 799         readerMock.On("GetNodeb", gnbNodebRanName).Return(nodebInfo, nil)
 800         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
 801
 802         notificationRequest := &models.NotificationRequest{RanName: gnbNodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
 803         gnbToUpdate := getExpectedNodebForExistingRan(nodebInfo, notificationRequest.Payload)
 804         gnbToUpdate2 := *gnbToUpdate
 805         gnbToUpdate2.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 806         gnbToUpdate2.SetupFromNetwork = true
 807         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", mock.Anything, gnbNodebRanName+"_CONNECTED").Return(nil)
 808         gnbToUpdate3 := *gnbToUpdate
 809         gnbToUpdate3.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 810         gnbToUpdate3.SetupFromNetwork = true
 811         gnbToUpdate3.AssociatedE2TInstanceAddress = e2tInstanceFullAddress
 812         writerMock.On("UpdateNodebInfo", mock.Anything).Return(nil)
 813
 814         newNbIdentity := &entities.NbIdentity{InventoryName: gnbNodebRanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 815         writerMock.On("UpdateNbIdentities", gnbToUpdate3.GetNodeType(), []*entities.NbIdentity{oldNbIdentity}, []*entities.NbIdentity{newNbIdentity}).Return(nil)
 816
 817         e2tInstancesManagerMock.On("AddRansToInstance", e2tInstanceFullAddress, []string{gnbNodebRanName}).Return(nil)
 818         var errEmpty error
 819         rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(&rmrCgo.MBuf{}, errEmpty)
 820         handler.Handle(notificationRequest)
 821         readerMock.AssertExpectations(t)
 822         writerMock.AssertExpectations(t)
 823         e2tInstancesManagerMock.AssertExpectations(t)
 824 }
 825
 826 /* Existing Ran UTs - END */