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