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