E2Manager/handlers/rmrmsghandlers/e2_setup_request_notification_handler_test.go

   1 //
   2 // Copyright 2019 AT&T Intellectual Property
   3 // Copyright 2019 Nokia
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the "License");
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //      http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16
  17 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
  18 //  platform project (RICP).
  19
  20 package rmrmsghandlers
  21
  22 import (
  23         "bytes"
  24         "e2mgr/configuration"
  25         "e2mgr/logger"
  26         "e2mgr/managers"
  27         "e2mgr/mocks"
  28         "e2mgr/models"
  29         "e2mgr/services"
  30         "e2mgr/tests"
  31         "errors"
  32         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  33         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  34         "github.com/stretchr/testify/assert"
  35         "github.com/stretchr/testify/mock"
  36         "io"
  37         "io/ioutil"
  38         "os"
  39         "path/filepath"
  40         "testing"
  41 )
  42
  43 const (
  44         prefix = "10.0.2.15:9999|"
  45         logFilePath = "./loggerTest.txt"
  46         e2tInstanceAddress = "10.0.2.15"
  47         nodebRanName = "gnb:310-410-b5c67788"
  48 )
  49
  50 func TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess(t *testing.T) {
  51         path, err :=filepath.Abs("../../tests/resources/setupRequest_gnb.xml")
  52         if err != nil {
  53                 t.Fatal(err)
  54         }
  55         xmlGnb, err := ioutil.ReadFile(path)
  56         if err != nil {
  57                 t.Fatal(err)
  58         }
  59
  60         logFile, err := os.Create(logFilePath)
  61         if err != nil{
  62                 t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess - failed to create file, error: %s", err)
  63         }
  64         oldStdout := os.Stdout
  65         defer changeStdout(oldStdout)
  66         defer removeLogFile(t)
  67         os.Stdout = logFile
  68
  69         handler := stubMockSuccessFlowNewNodeb(t)
  70         prefBytes := []byte(prefix)
  71         notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, xmlGnb...)}
  72         handler.Handle(notificationRequest)
  73         assertSuccessFlowNewNodebLogs(t)
  74 }
  75
  76 func TestE2SetupRequestNotificationHandler_HandleNewEnGnbSuccess(t *testing.T) {
  77         path, err :=filepath.Abs("../../tests/resources/setupRequest_en-gNB.xml")
  78         if err != nil {
  79                 t.Fatal(err)
  80         }
  81         xmlEnGnb, err := ioutil.ReadFile(path)
  82         if err != nil {
  83                 t.Fatal(err)
  84         }
  85         logFile, err := os.Create(logFilePath)
  86         if err != nil{
  87                 t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleNewEnGnbSuccess - failed to create file, error: %s", err)
  88         }
  89         oldStdout := os.Stdout
  90         defer changeStdout(oldStdout)
  91         defer removeLogFile(t)
  92         os.Stdout = logFile
  93
  94         handler := stubMockSuccessFlowNewNodeb(t)
  95         prefBytes := []byte(prefix)
  96         notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, xmlEnGnb...)}
  97         handler.Handle(notificationRequest)
  98         assertSuccessFlowNewNodebLogs(t)
  99 }
 100
 101 func TestE2SetupRequestNotificationHandler_HandleNewNgEnbSuccess(t *testing.T) {
 102         path, err :=filepath.Abs("../../tests/resources/setupRequest_ng-eNB.xml")
 103         if err != nil {
 104                 t.Fatal(err)
 105         }
 106         xmlEnGnb, err := ioutil.ReadFile(path)
 107         if err != nil {
 108                 t.Fatal(err)
 109         }
 110         logFile, err := os.Create(logFilePath)
 111         if err != nil{
 112                 t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleNewNgEnbSuccess - failed to create file, error: %s", err)
 113         }
 114         oldStdout := os.Stdout
 115         defer changeStdout(oldStdout)
 116         defer removeLogFile(t)
 117         os.Stdout = logFile
 118
 119         handler := stubMockSuccessFlowNewNodeb(t)
 120         prefBytes := []byte(prefix)
 121         notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, xmlEnGnb...)}
 122         handler.Handle(notificationRequest)
 123         assertSuccessFlowNewNodebLogs(t)
 124 }
 125
 126 func TestE2SetupRequestNotificationHandler_HandleExistingGnbSuccess(t *testing.T) {
 127         path, err :=filepath.Abs("../../tests/resources/setupRequest_gnb.xml")
 128         if err != nil {
 129                 t.Fatal(err)
 130         }
 131         xmlGnb, err := ioutil.ReadFile(path)
 132         if err != nil {
 133                 t.Fatal(err)
 134         }
 135
 136         logFile, err := os.Create(logFilePath)
 137         if err != nil{
 138                 t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess - failed to create file, error: %s", err)
 139         }
 140         oldStdout := os.Stdout
 141         defer changeStdout(oldStdout)
 142         defer removeLogFile(t)
 143         os.Stdout = logFile
 144
 145         handler := stubMockSuccessFlowExistingNodeb(t)
 146         prefBytes := []byte(prefix)
 147         notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, xmlGnb...)}
 148         handler.Handle(notificationRequest)
 149         assertSuccessFlowExistingNodebLogs(t)
 150 }
 151
 152 func TestE2SetupRequestNotificationHandler_HandleParseError(t *testing.T) {
 153         path, err :=filepath.Abs("../../tests/resources/setupRequest_gnb.xml")
 154         if err != nil {
 155                 t.Fatal(err)
 156         }
 157         xmlGnb, err := ioutil.ReadFile(path)
 158         if err != nil {
 159                 t.Fatal(err)
 160         }
 161
 162         logFile, err := os.Create(logFilePath)
 163         if err != nil{
 164                 t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess - failed to create file, error: %s", err)
 165         }
 166         oldStdout := os.Stdout
 167         defer changeStdout(oldStdout)
 168         defer removeLogFile(t)
 169         os.Stdout = logFile
 170
 171         _, handler, _, _, _, _, _ := initMocks(t)
 172         prefBytes := []byte("invalid_prefix")
 173         notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, xmlGnb...)}
 174         handler.Handle(notificationRequest)
 175         assertParseErrorFlowLogs(t)
 176 }
 177
 178 func TestE2SetupRequestNotificationHandler_HandleUnmarshalError(t *testing.T) {
 179         logFile, err := os.Create(logFilePath)
 180         if err != nil{
 181                 t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess - failed to create file, error: %s", err)
 182         }
 183         oldStdout := os.Stdout
 184         defer changeStdout(oldStdout)
 185         defer removeLogFile(t)
 186         os.Stdout = logFile
 187
 188         _, handler, _, _, _, _, _ := initMocks(t)
 189         prefBytes := []byte(prefix)
 190         notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, "xmlGnb"...)}
 191         handler.Handle(notificationRequest)
 192         assertUnmarshalErrorFlowLogs(t)
 193 }
 194
 195 func TestE2SetupRequestNotificationHandler_HandleGetE2TInstanceError(t *testing.T) {
 196         path, err :=filepath.Abs("../../tests/resources/setupRequest_gnb.xml")
 197         if err != nil {
 198                 t.Fatal(err)
 199         }
 200         xmlGnb, err := ioutil.ReadFile(path)
 201         if err != nil {
 202                 t.Fatal(err)
 203         }
 204
 205         logFile, err := os.Create(logFilePath)
 206         if err != nil{
 207                 t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess - failed to create file, error: %s", err)
 208         }
 209         oldStdout := os.Stdout
 210         defer changeStdout(oldStdout)
 211         defer removeLogFile(t)
 212         os.Stdout = logFile
 213
 214         _, handler, _, _, _, e2tInstancesManagerMock, _ := initMocks(t)
 215         var e2tInstance * entities.E2TInstance
 216         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewResourceNotFoundError("Not found"))
 217         prefBytes := []byte(prefix)
 218         notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, xmlGnb...)}
 219         handler.Handle(notificationRequest)
 220         assertGetE2TInstanceErrorLogs(t)
 221 }
 222
 223 func TestE2SetupRequestNotificationHandler_HandleGetNodebError(t *testing.T) {
 224         path, err :=filepath.Abs("../../tests/resources/setupRequest_gnb.xml")
 225         if err != nil {
 226                 t.Fatal(err)
 227         }
 228         xmlGnb, err := ioutil.ReadFile(path)
 229         if err != nil {
 230                 t.Fatal(err)
 231         }
 232
 233         logFile, err := os.Create(logFilePath)
 234         if err != nil{
 235                 t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess - failed to create file, error: %s", err)
 236         }
 237         oldStdout := os.Stdout
 238         defer changeStdout(oldStdout)
 239         defer removeLogFile(t)
 240         os.Stdout = logFile
 241         _, handler, readerMock, _, _, e2tInstancesManagerMock, _ := initMocks(t)
 242         var e2tInstance = &entities.E2TInstance{}
 243         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
 244         var gnb *entities.NodebInfo
 245         readerMock.On("GetNodeb", mock.Anything).Return(gnb, common.NewInternalError(errors.New("Some error")))
 246         prefBytes := []byte(prefix)
 247         notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, xmlGnb...)}
 248         handler.Handle(notificationRequest)
 249         assertGetNodebErrorLogs(t)
 250 }
 251
 252 func TestE2SetupRequestNotificationHandler_HandleAssociationError(t *testing.T) {
 253         path, err :=filepath.Abs("../../tests/resources/setupRequest_gnb.xml")
 254         if err != nil {
 255                 t.Fatal(err)
 256         }
 257         xmlGnb, err := ioutil.ReadFile(path)
 258         if err != nil {
 259                 t.Fatal(err)
 260         }
 261
 262         logFile, err := os.Create(logFilePath)
 263         if err != nil{
 264                 t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess - failed to create file, error: %s", err)
 265         }
 266         oldStdout := os.Stdout
 267         defer changeStdout(oldStdout)
 268         defer removeLogFile(t)
 269         os.Stdout = logFile
 270
 271         _, handler, readerMock, writerMock, _, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 272         var e2tInstance = &entities.E2TInstance{}
 273         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
 274         var gnb *entities.NodebInfo
 275         readerMock.On("GetNodeb", mock.Anything).Return(gnb, common.NewResourceNotFoundError("Not found"))
 276         writerMock.On("SaveNodeb", mock.Anything, mock.Anything).Return(nil)
 277         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceAddress, mock.Anything).Return(errors.New("association error"))
 278
 279         prefBytes := []byte(prefix)
 280         notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, xmlGnb...)}
 281         handler.Handle(notificationRequest)
 282         assertAssociationErrorLogs(t)
 283 }
 284
 285 func TestE2SetupRequestNotificationHandler_HandleExistingGnbInvalidStatusError(t *testing.T) {
 286         path, err :=filepath.Abs("../../tests/resources/setupRequest_gnb.xml")
 287         if err != nil {
 288                 t.Fatal(err)
 289         }
 290         xmlGnb, err := ioutil.ReadFile(path)
 291         if err != nil {
 292                 t.Fatal(err)
 293         }
 294
 295         logFile, err := os.Create(logFilePath)
 296         if err != nil{
 297                 t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess - failed to create file, error: %s", err)
 298         }
 299         oldStdout := os.Stdout
 300         defer changeStdout(oldStdout)
 301         defer removeLogFile(t)
 302         os.Stdout = logFile
 303
 304         handler := stubMockInvalidStatusFlowExistingNodeb(t)
 305         prefBytes := []byte(prefix)
 306         notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, xmlGnb...)}
 307         handler.Handle(notificationRequest)
 308         assertInvalidNodebStatusLogs(t)
 309 }
 310
 311 func assertInvalidNodebStatusLogs(t *testing.T){
 312         buf := getLogFileBuffer(t)
 313         assertReceivedAndParsedLog(buf, t)
 314         assertInvalidNodebStatusLog(buf, t)
 315         assertNoMoreRecordsLog(buf, t)
 316 }
 317
 318 func assertInvalidNodebStatusLog(buf *bytes.Buffer, t *testing.T) {
 319         record, _ := buf.ReadString('\n')
 320         assert.Contains(t, record, "#RnibDataService.GetNodeb")
 321         assert.Contains(t, record, "connection status: SHUTTING_DOWN")
 322         record, _ = buf.ReadString('\n')
 323         assert.Contains(t, record, "#E2SetupRequestNotificationHandler.Handle")
 324         assert.Contains(t, record, "connection status: SHUTTING_DOWN - nodeB entity in incorrect state")
 325         record, _ = buf.ReadString('\n')
 326         assert.Contains(t, record, "#E2SetupRequestNotificationHandler.Handle")
 327         assert.Contains(t, record, "Summary: elapsed time for receiving and handling setup request message from E2 terminator")
 328 }
 329
 330 func assertAssociationErrorLogs(t *testing.T){
 331         buf := getLogFileBuffer(t)
 332         assertReceivedAndParsedLog(buf, t)
 333         assertNewNodebSavedLog(buf, t)
 334         assertAssociationErrorLog(buf, t)
 335         assertNoMoreRecordsLog(buf, t)
 336 }
 337
 338 func assertAssociationErrorLog(buf *bytes.Buffer, t *testing.T) {
 339         record, _ := buf.ReadString('\n')
 340         assert.Contains(t, record, "#E2TAssociationManager.AssociateRan - Associating RAN")
 341         record, _ = buf.ReadString('\n')
 342         assert.Contains(t, record, "#E2TAssociationManager.AssociateRan - RoutingManager failure: Failed to associate RAN")
 343         record, _ = buf.ReadString('\n')
 344         assert.Contains(t, record, "#E2SetupRequestNotificationHandler.Handle - RAN name:")
 345         assert.Contains(t, record, "failed to associate E2T to nodeB entity")
 346 }
 347
 348 func assertGetNodebErrorLogs(t *testing.T) {
 349         buf := getLogFileBuffer(t)
 350         assertReceivedAndParsedLog(buf, t)
 351         assertGetNodebErrorLog(buf, t)
 352         assertNoMoreRecordsLog(buf, t)
 353 }
 354
 355 func assertGetNodebErrorLog(buf *bytes.Buffer, t *testing.T) {
 356         record, _ := buf.ReadString('\n')
 357         assert.Contains(t, record, "failed to retrieve nodebInfo entity")
 358 }
 359
 360 func assertGetE2TInstanceErrorLogs(t *testing.T) {
 361         buf := getLogFileBuffer(t)
 362         assertReceivedAndParsedLog(buf, t)
 363         assertGetE2TInstanceErrorLog(buf, t)
 364         assertNoMoreRecordsLog(buf, t)
 365 }
 366
 367 func assertGetE2TInstanceErrorLog(buf *bytes.Buffer, t *testing.T) {
 368         record, _ := buf.ReadString('\n')
 369         assert.Contains(t, record, "Failed retrieving E2TInstance")
 370 }
 371
 372 func removeLogFile(t *testing.T) {
 373         err := os.Remove(logFilePath)
 374         if err != nil {
 375                 t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleGnbSuccess - failed to remove file, error: %s", err)
 376         }
 377 }
 378
 379 func assertParseErrorFlowLogs(t *testing.T) {
 380         buf := getLogFileBuffer(t)
 381         assertReceivedAndFailedParseLog(buf, t)
 382         assertNoMoreRecordsLog(buf, t)
 383 }
 384
 385 func assertUnmarshalErrorFlowLogs(t *testing.T) {
 386         buf := getLogFileBuffer(t)
 387         assertReceivedAndFailedUnmarshalLog(buf, t)
 388         assertNoMoreRecordsLog(buf, t)
 389 }
 390
 391 func assertSuccessFlowNewNodebLogs(t *testing.T){
 392         buf := getLogFileBuffer(t)
 393         assertReceivedAndParsedLog(buf, t)
 394         assertNewNodebSavedLog(buf, t)
 395         assertAssociatedLog(buf, t)
 396         assertRequestBuiltLog(buf, t)
 397         assertNoMoreRecordsLog(buf, t)
 398 }
 399
 400 func assertSuccessFlowExistingNodebLogs(t *testing.T){
 401         buf := getLogFileBuffer(t)
 402         assertReceivedAndParsedLog(buf, t)
 403         assertExistingNodebRetrievedLog(buf, t)
 404         assertAssociatedLog(buf, t)
 405         assertRequestBuiltLog(buf, t)
 406         assertNoMoreRecordsLog(buf, t)
 407 }
 408
 409 func assertReceivedAndParsedLog(buf *bytes.Buffer, t *testing.T) {
 410         record, _ := buf.ReadString('\n')
 411         assert.Contains(t, record, "received E2 Setup Request")
 412         record, _ = buf.ReadString('\n')
 413         assert.Contains(t, record, "handling E2_SETUP_REQUEST")
 414 }
 415
 416 func assertReceivedAndFailedParseLog(buf *bytes.Buffer, t *testing.T) {
 417         record, _ := buf.ReadString('\n')
 418         assert.Contains(t, record, "received E2 Setup Request")
 419         record, _ = buf.ReadString('\n')
 420         assert.Contains(t, record, "Error parsing E2 Setup Request")
 421 }
 422
 423 func assertReceivedAndFailedUnmarshalLog(buf *bytes.Buffer, t *testing.T) {
 424         record, _ := buf.ReadString('\n')
 425         assert.Contains(t, record, "received E2 Setup Request")
 426         record, _ = buf.ReadString('\n')
 427         assert.Contains(t, record, "Error unmarshalling E2 Setup Request")
 428 }
 429
 430 func assertNewNodebSavedLog(buf *bytes.Buffer, t *testing.T) {
 431         record, _ := buf.ReadString('\n')
 432         assert.Contains(t, record, "#RnibDataService.SaveNodeb - nbIdentity:")
 433 }
 434
 435 func assertExistingNodebRetrievedLog(buf *bytes.Buffer, t *testing.T) {
 436         record, _ := buf.ReadString('\n')
 437         assert.Contains(t, record, "#RnibDataService.GetNodeb - RAN name:")
 438 }
 439
 440 func assertAssociatedLog(buf *bytes.Buffer, t *testing.T){
 441         record, _ := buf.ReadString('\n')
 442         assert.Contains(t, record, "#E2TAssociationManager.AssociateRan - Associating RAN")
 443         record, _ = buf.ReadString('\n')
 444         assert.Contains(t, record, "#RnibDataService.UpdateNodebInfo")
 445         record, _ = buf.ReadString('\n')
 446         assert.Contains(t, record, "#E2TAssociationManager.AssociateRan - successfully associated RAN")
 447 }
 448
 449 func assertRequestBuiltLog(buf *bytes.Buffer, t *testing.T) {
 450         record, _ := buf.ReadString('\n')
 451         assert.Contains(t, record, "E2 Setup Request has been built")
 452 }
 453
 454 func assertNoMoreRecordsLog(buf *bytes.Buffer, t *testing.T) {
 455         record, _ := buf.ReadString('\n')
 456         assert.Empty(t, record)
 457 }
 458
 459 func stubMockSuccessFlowNewNodeb(t *testing.T) E2SetupRequestNotificationHandler{
 460         _, handler, readerMock, writerMock, _, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 461         var e2tInstance = &entities.E2TInstance{}
 462         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
 463         var gnb *entities.NodebInfo
 464         readerMock.On("GetNodeb", mock.Anything).Return(gnb, common.NewResourceNotFoundError("Not found"))
 465         writerMock.On("SaveNodeb", mock.Anything, mock.Anything).Return(nil)
 466         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceAddress, mock.Anything).Return(nil)
 467         writerMock.On("UpdateNodebInfo", mock.Anything).Return(nil)
 468         e2tInstancesManagerMock.On("AddRansToInstance", mock.Anything, mock.Anything).Return(nil)
 469         return handler
 470 }
 471
 472 func stubMockSuccessFlowExistingNodeb(t *testing.T) E2SetupRequestNotificationHandler{
 473         _, handler, readerMock, writerMock, _, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
 474         var e2tInstance = &entities.E2TInstance{}
 475         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
 476         var gnb = &entities.NodebInfo{RanName: nodebRanName}
 477         readerMock.On("GetNodeb", mock.Anything).Return(gnb, nil)
 478         routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceAddress, mock.Anything).Return(nil)
 479         writerMock.On("UpdateNodebInfo", mock.Anything).Return(nil)
 480         e2tInstancesManagerMock.On("AddRansToInstance", mock.Anything, mock.Anything).Return(nil)
 481         return handler
 482 }
 483
 484 func stubMockInvalidStatusFlowExistingNodeb(t *testing.T) E2SetupRequestNotificationHandler{
 485         _, handler, readerMock, _, _, e2tInstancesManagerMock, _ := initMocks(t)
 486         var e2tInstance = &entities.E2TInstance{}
 487         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
 488         var gnb = &entities.NodebInfo{RanName: nodebRanName, ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN}
 489         readerMock.On("GetNodeb", mock.Anything).Return(gnb, nil)
 490         return handler
 491 }
 492
 493 func initMocks(t *testing.T) (*logger.Logger, E2SetupRequestNotificationHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock, *mocks.RoutingManagerClientMock) {
 494         logger := tests.InitLog(t)
 495         config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
 496         rmrMessengerMock := &mocks.RmrMessengerMock{}
 497         rmrSender := tests.InitRmrSender(rmrMessengerMock, logger)
 498         readerMock := &mocks.RnibReaderMock{}
 499         writerMock := &mocks.RnibWriterMock{}
 500         routingManagerClientMock := &mocks.RoutingManagerClientMock{}
 501         rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
 502         e2tInstancesManagerMock := &mocks.E2TInstancesManagerMock{}
 503         e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManagerMock, routingManagerClientMock)
 504         handler := NewE2SetupRequestNotificationHandler(logger, e2tInstancesManagerMock, rmrSender, rnibDataService, e2tAssociationManager)
 505         return logger, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock
 506 }
 507
 508 func changeStdout(old *os.File) {
 509         os.Stdout = old
 510 }
 511
 512 func getLogFileBuffer(t *testing.T) *bytes.Buffer {
 513         logFile, err := os.Open(logFilePath)
 514         if err != nil {
 515                 t.Errorf("e2_setup_request_notification_handler_test.assertSuccessFlowNewNodebLogRecords - failed to open file, error: %s", err)
 516         }
 517         var buf bytes.Buffer
 518         _, err = io.Copy(&buf, logFile)
 519         if err != nil {
 520                 t.Errorf("e2_setup_request_notification_handler_test.assertSuccessFlowNewNodebLogRecords - failed to copy bytes, error: %s", err)
 521         }
 522         return &buf
 523 }
 524