f03a1c4bd59cc69d9e0c3ff65936d2cdbce624c0
[ric-plt/e2mgr.git] / 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 */