E2Manager/handlers/rmrmsghandlers/e2_setup_request_notification_handler_test.go

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