[RIC-475] Enhance LostConnection flow + UTs 12/4212/1
authoridanshal <idan.shalom@intl.att.com>
Sun, 21 Jun 2020 08:05:02 +0000 (11:05 +0300)
committeridanshal <idan.shalom@intl.att.com>
Sun, 21 Jun 2020 08:05:22 +0000 (11:05 +0300)
Change-Id: If01dceba37069ad285fd27f96c8ff47c1a0a05a1
Signed-off-by: idanshal <idan.shalom@intl.att.com>
16 files changed:
E2Manager/app/main.go
E2Manager/container-tag.yaml
E2Manager/handlers/rmrmsghandlers/e2_setup_request_notification_handler.go
E2Manager/handlers/rmrmsghandlers/e2_term_init_notification_handler.go
E2Manager/handlers/rmrmsghandlers/e2_term_init_notification_handler_test.go
E2Manager/handlers/rmrmsghandlers/ran_lost_connection_handler.go
E2Manager/handlers/rmrmsghandlers/ran_lost_connection_handler_test.go
E2Manager/managers/e2t_association_manager.go
E2Manager/managers/e2t_instances_manager.go
E2Manager/managers/notificationmanager/notification_manager_test.go
E2Manager/managers/ran_disconnection_manager.go
E2Manager/managers/ran_disconnection_manager_test.go
E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider.go
E2Manager/providers/rmrmsghandlerprovider/notification_handler_provider.go
E2Manager/providers/rmrmsghandlerprovider/notification_handler_provider_test.go
E2Manager/services/rmrreceiver/rmr_receiver_test.go

index 8eb5a64..5dd1922 100644 (file)
@@ -68,7 +68,7 @@ func main() {
        e2tShutdownManager := managers.NewE2TShutdownManager(logger, config, rnibDataService, e2tInstancesManager, e2tAssociationManager, kubernetes)
        e2tKeepAliveWorker := managers.NewE2TKeepAliveWorker(logger, rmrSender, e2tInstancesManager, e2tShutdownManager, config)
        rmrNotificationHandlerProvider := rmrmsghandlerprovider.NewNotificationHandlerProvider()
-       rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager)
+       rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager)
 
        notificationManager := notificationmanager.NewNotificationManager(logger, rmrNotificationHandlerProvider)
        rmrReceiver := rmrreceiver.NewRmrReceiver(logger, rmrMessenger, notificationManager)
index e6c6a80..6eeabcf 100644 (file)
@@ -1,4 +1,4 @@
 # The Jenkins job requires a tag to build the Docker image.
 # Global-JJB script assumes this file is in the repo root.
 ---
-tag: 5.2.2
+tag: 5.2.3
index c5f5e4a..b2f9898 100644 (file)
@@ -72,7 +72,7 @@ func (h *E2SetupRequestNotificationHandler) Handle(request *models.NotificationR
        generalConfiguration, err := h.rNibDataService.GetGeneralConfiguration()
 
        if err != nil {
-               h.logger.Errorf("#E2SetupRequestNotificationHandler.Handle - Failed retrieving e2m general configuration. error: %s", err)
+               h.logger.Errorf("#E2SetupRequestNotificationHandler.Handle - Failed retrieving e2m general configuration - quitting e2 setup flow. error: %s", err)
                return
        }
 
index 4aa4039..d11158b 100644 (file)
@@ -17,7 +17,6 @@
 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
 //  platform project (RICP).
 
-
 package rmrmsghandlers
 
 import (
@@ -83,7 +82,7 @@ func (h E2TermInitNotificationHandler) Handle(request *models.NotificationReques
                return
        }
 
-       if e2tInstance.State == entities.ToBeDeleted{
+       if e2tInstance.State == entities.ToBeDeleted {
                h.logger.Infof("#E2TermInitNotificationHandler.Handle - E2T Address: %s - E2T instance status is: %s, ignore", e2tInstance.Address, e2tInstance.State)
                return
        }
@@ -98,7 +97,7 @@ func (h E2TermInitNotificationHandler) HandleExistingE2TInstance(e2tInstance *en
        for _, ranName := range e2tInstance.AssociatedRanList {
 
                if err := h.ranDisconnectionManager.DisconnectRan(ranName); err != nil {
-                       if _, ok := err.(*common.ResourceNotFoundError); !ok{
+                       if _, ok := err.(*common.ResourceNotFoundError); !ok {
                                break
                        }
                }
@@ -109,10 +108,10 @@ func (h E2TermInitNotificationHandler) HandleNewE2TInstance(e2tAddress string, p
 
        err := h.routingManagerClient.AddE2TInstance(e2tAddress)
 
-       if err != nil{
+       if err != nil {
                h.logger.Errorf("#E2TermInitNotificationHandler.HandleNewE2TInstance - e2t address: %s - routing manager failure", e2tAddress)
                return
        }
 
        _ = h.e2tInstancesManager.AddE2TInstance(e2tAddress, podName)
-}
\ No newline at end of file
+}
index 6277b4d..befb3b2 100644 (file)
+////
+//// Copyright 2019 AT&T Intellectual Property
+//// Copyright 2019 Nokia
+////
+//// Licensed under the Apache License, Version 2.0 (the "License");
+//// you may not use this file except in compliance with the License.
+//// You may obtain a copy of the License at
+////
+////      http://www.apache.org/licenses/LICENSE-2.0
+////
+//// Unless required by applicable law or agreed to in writing, software
+//// distributed under the License is distributed on an "AS IS" BASIS,
+//// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//// See the License for the specific language governing permissions and
+//// limitations under the License.
+////
 //
-// Copyright 2019 AT&T Intellectual Property
-// Copyright 2019 Nokia
+////  This source code is part of the near-RT RIC (RAN Intelligent Controller)
+////  platform project (RICP).
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-//  This source code is part of the near-RT RIC (RAN Intelligent Controller)
-//  platform project (RICP).
-
 package rmrmsghandlers
 
 import (
-       "bytes"
-       "e2mgr/clients"
-       "e2mgr/configuration"
        "e2mgr/logger"
-       "e2mgr/managers"
        "e2mgr/mocks"
-       "e2mgr/models"
        "e2mgr/rmrCgo"
-       "e2mgr/services"
        "e2mgr/services/rmrsender"
        "e2mgr/tests"
-       "fmt"
-       "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
-       "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
-       "github.com/pkg/errors"
-       "github.com/stretchr/testify/mock"
-       "io/ioutil"
-       "net/http"
        "testing"
 )
 
-const (
-       e2tInitPayload = "{\"address\":\"10.0.2.15\", \"fqdn\":\"\"}"
-       e2tInstanceAddress = "10.0.2.15"
-       podName = "podNAme_test"
-)
-
-func initRanLostConnectionTest(t *testing.T) (*logger.Logger, E2TermInitNotificationHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.E2TInstancesManagerMock, *mocks.RoutingManagerClientMock) {
-
-       logger := initLog(t)
-       config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
-
-       readerMock := &mocks.RnibReaderMock{}
-
-       writerMock := &mocks.RnibWriterMock{}
-
-       routingManagerClientMock := &mocks.RoutingManagerClientMock{}
-
-       rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
-
-       e2tInstancesManagerMock := &mocks.E2TInstancesManagerMock{}
-
-       ranListManager := &mocks.RanListManagerMock{}
-       ranAlarmService := &mocks.RanAlarmServiceMock{}
-       ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService,ranListManager, ranAlarmService)
-       e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManagerMock, routingManagerClientMock, ranConnectStatusChangeManager)
-
-       ranDisconnectionManager := managers.NewRanDisconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, e2tAssociationManager)
-       handler := NewE2TermInitNotificationHandler(logger, ranDisconnectionManager, e2tInstancesManagerMock, routingManagerClientMock)
-
-       return logger, handler, readerMock, writerMock, e2tInstancesManagerMock, routingManagerClientMock
-}
-
-func initRanLostConnectionTestWithRealE2tInstanceManager(t *testing.T) (*logger.Logger, *configuration.Configuration, E2TermInitNotificationHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.HttpClientMock) {
-
-       logger := initLog(t)
-       config := configuration.ParseConfiguration()
-
-       readerMock := &mocks.RnibReaderMock{}
-
-       writerMock := &mocks.RnibWriterMock{}
-       httpClientMock := &mocks.HttpClientMock{}
-
-       routingManagerClient := clients.NewRoutingManagerClient(logger, config, httpClientMock)
-       rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
-
-       e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, logger)
-       ranListManager := managers.NewRanListManager(logger)
-       ranAlarmService := services.NewRanAlarmService(logger, config)
-       ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService,ranListManager, ranAlarmService)
-       e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManager, routingManagerClient, ranConnectStatusChangeManager)
-       ranDisconnectionManager := managers.NewRanDisconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, e2tAssociationManager)
-       handler := NewE2TermInitNotificationHandler(logger, ranDisconnectionManager, e2tInstancesManager, routingManagerClient)
-       return logger, config, handler, readerMock, writerMock, httpClientMock
-}
-
-func TestE2TermInitUnmarshalPayloadFailure(t *testing.T) {
-       _, handler, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
-       notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte("asd")}
-       handler.Handle(notificationRequest)
-       e2tInstancesManagerMock.AssertNotCalled(t, "GetE2TInstance")
-       e2tInstancesManagerMock.AssertNotCalled(t, "AddE2TInstance")
-}
-
-func TestE2TermInitEmptyE2TAddress(t *testing.T) {
-       _, handler, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
-       notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte("{\"address\":\"\"}")}
-       handler.Handle(notificationRequest)
-       e2tInstancesManagerMock.AssertNotCalled(t, "GetE2TInstance")
-       e2tInstancesManagerMock.AssertNotCalled(t, "AddE2TInstance")
-}
-
-func TestE2TermInitGetE2TInstanceFailure(t *testing.T) {
-       _, handler, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
-       var e2tInstance *entities.E2TInstance
-       e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewInternalError(fmt.Errorf("internal error")))
-       notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
-       handler.Handle(notificationRequest)
-       e2tInstancesManagerMock.AssertNotCalled(t, "AddE2TInstance")
-}
-
-func TestE2TermInitGetE2TInstanceDbFailure(t *testing.T) {
-       _, _, handler, readerMock, writerMock, _ := initRanLostConnectionTestWithRealE2tInstanceManager(t)
-       var e2tInstance *entities.E2TInstance
-       readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewInternalError(fmt.Errorf("internal error")))
-       notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
-       handler.Handle(notificationRequest)
-       writerMock.AssertNotCalled(t, "UpdateNodebInfo")
-}
-
-func TestE2TermInitNewE2TInstance(t *testing.T) {
-       _, config, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
-       var e2tInstance *entities.E2TInstance
-
-       readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewResourceNotFoundError("not found"))
-       writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
-
-       respBody := ioutil.NopCloser(bytes.NewBufferString(""))
-       url := config.RoutingManager.BaseUrl + clients.AddE2TInstanceApiSuffix
-       httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
-
-       e2tAddresses := []string{}
-       readerMock.On("GetE2TAddresses").Return(e2tAddresses, common.NewResourceNotFoundError(""))
-
-       e2tAddresses = append(e2tAddresses, e2tInstanceAddress)
-       writerMock.On("SaveE2TAddresses", e2tAddresses).Return(nil)
-
-       notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
-       handler.Handle(notificationRequest)
-
-       httpClientMock.AssertCalled(t, "Post", url, mock.Anything, mock.Anything)
-       writerMock.AssertCalled(t, "SaveE2TInstance", mock.Anything)
-       writerMock.AssertCalled(t, "SaveE2TAddresses", e2tAddresses)
-}
-
-func TestE2TermInitNewE2TInstance__RoutingManagerError(t *testing.T) {
-       _, config, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
-
-       var e2tInstance *entities.E2TInstance
-
-       readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewResourceNotFoundError("not found"))
-
-       url := config.RoutingManager.BaseUrl + clients.AddE2TInstanceApiSuffix
-       httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{}, errors.New("error"))
-
-       notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
-       handler.Handle(notificationRequest)
-
-       writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 0)
-}
-
-func TestE2TermInitExistingE2TInstanceNoAssociatedRans(t *testing.T) {
-       _, handler, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
-       e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
-       e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
-       notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
-       handler.Handle(notificationRequest)
-       e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceAddress)
-}
-
-func TestE2TermInitHandlerSuccessOneRan(t *testing.T) {
-       _, config, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
-
-       var rnibErr error
-       var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
-       readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
-
-       var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
-       writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
-
-       var disconnectedNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
-       readerMock.On("GetNodeb", RanName).Return(disconnectedNodeb, rnibErr)
-
-       var updatedNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: ""}
-       writerMock.On("UpdateNodebInfo", updatedNodeb).Return(rnibErr)
-
-       e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
-       e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
-       readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
-       writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
-
-       respBody := ioutil.NopCloser(bytes.NewBufferString(""))
-       url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
-       httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
-
-       notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
-
-       handler.Handle(notificationRequest)
-
-       writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
-       writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
-       httpClientMock.AssertNumberOfCalls(t, "Post", 1)
-}
-
-func TestE2TermInitHandlerSuccessOneRan_RoutingManagerError(t *testing.T) {
-       _, config, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
-
-       var rnibErr error
-       var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
-       readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
-
-       var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
-       writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
-
-       var disconnectedNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
-       readerMock.On("GetNodeb", RanName).Return(disconnectedNodeb, rnibErr)
-
-       var updatedNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: ""}
-       writerMock.On("UpdateNodebInfo", updatedNodeb).Return(rnibErr)
-
-       e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
-       e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
-       readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
-       writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
-
-       url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
-       httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{}, errors.New("error"))
-
-       notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
-
-       handler.Handle(notificationRequest)
-
-       writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
-       writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
-       httpClientMock.AssertNumberOfCalls(t, "Post", 1)
-}
-
-func TestE2TermInitHandlerSuccessOneRanShuttingdown(t *testing.T) {
-       _, _, handler, readerMock, writerMock, _ := initRanLostConnectionTestWithRealE2tInstanceManager(t)
-       var rnibErr error
-
-       var initialNodeb = &entities.NodebInfo{RanName: RanName, ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
-       readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
-
-       var argNodeb = &entities.NodebInfo{RanName: RanName, ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
-       writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
-
-       e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
-       e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
-       readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
-       notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
-
-       handler.Handle(notificationRequest)
-
-       writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
-}
-
-func TestE2TermInitHandlerSuccessOneRan_ToBeDeleted(t *testing.T) {
-       _, _, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
-       var rnibErr error
-
-       var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
-       readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
-
-       var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
-       writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
-
-       e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
-       e2tInstance.State = entities.ToBeDeleted
-       e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
-
-       readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
-       notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
-
-       handler.Handle(notificationRequest)
-
-       httpClientMock.AssertNotCalled(t, "Post", mock.Anything, mock.Anything, mock.Anything)
-       writerMock.AssertNotCalled(t, "UpdateNodebInfo")
-}
-
-func TestE2TermInitHandlerSuccessTwoRans(t *testing.T) {
-
-       _, config, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
-
-       var rnibErr error
-       test2 := "test2"
-
-       //First RAN
-       var firstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
-       var disconnectedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
-       readerMock.On("GetNodeb", RanName).Return(firstRan, rnibErr).Return(disconnectedFirstRan, rnibErr)
-
-       var updatedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
-       writerMock.On("UpdateNodebInfo", updatedFirstRan).Return(rnibErr)
-
-       var updatedDisconnectedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: ""}
-       writerMock.On("UpdateNodebInfo", updatedDisconnectedFirstRan).Return(rnibErr)
-
-       //Second RAN
-       var secondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
-       var disconnectedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
-       readerMock.On("GetNodeb", test2).Return(secondRan, rnibErr).Return(disconnectedSecondRan, rnibErr)
-
-       var updatedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
-       writerMock.On("UpdateNodebInfo", updatedSecondRan).Return(rnibErr)
-
-       var updatedDisconnectedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: ""}
-       writerMock.On("UpdateNodebInfo", updatedDisconnectedSecondRan).Return(rnibErr)
-
-       e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
-       e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
-       e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, test2)
-       readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
-       writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
-
-       respBody := ioutil.NopCloser(bytes.NewBufferString(""))
-       url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
-       httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
-
-       notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
-
-       handler.Handle(notificationRequest)
-
-       writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 4)
-       writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 2)
-       httpClientMock.AssertNumberOfCalls(t, "Post", 2)
-}
-
-func TestE2TermInitHandlerSuccessTwoRansSecondRanShutdown(t *testing.T) {
-       _, config, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
-
-       var rnibErr error
-       test2 := "test2"
-
-       //First RAN
-       var firstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
-       var disconnectedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
-       readerMock.On("GetNodeb", RanName).Return(firstRan, rnibErr).Return(disconnectedFirstRan, rnibErr)
-
-       var updatedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
-       writerMock.On("UpdateNodebInfo", updatedFirstRan).Return(rnibErr)
-
-       var updatedDisconnectedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: ""}
-       writerMock.On("UpdateNodebInfo", updatedDisconnectedFirstRan).Return(rnibErr)
-
-       //Second RAN
-       var secondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
-       readerMock.On("GetNodeb", test2).Return(secondRan, rnibErr)
-
-       e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
-       e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
-       readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
-       writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
-
-       respBody := ioutil.NopCloser(bytes.NewBufferString(""))
-       url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
-       httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
-
-       notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
-
-       handler.Handle(notificationRequest)
-
-       writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
-       writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
-       httpClientMock.AssertNumberOfCalls(t, "Post", 1)
-}
-
-func TestE2TermInitHandlerSuccessTwoRansFirstNotFoundFailure(t *testing.T) {
-       _, config, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
-
-       var rnibErr error
-       test2 := "test2"
-
-       //First RAN
-       var firstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
-       readerMock.On("GetNodeb", RanName).Return(firstRan, common.NewResourceNotFoundError("not found"))
-
-       //Second RAN
-       var secondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
-       var disconnectedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
-       readerMock.On("GetNodeb", test2).Return(secondRan, rnibErr).Return(disconnectedSecondRan, rnibErr)
-
-       var updatedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
-       writerMock.On("UpdateNodebInfo", updatedSecondRan).Return(rnibErr)
-
-       var updatedDisconnectedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: ""}
-       writerMock.On("UpdateNodebInfo", updatedDisconnectedSecondRan).Return(rnibErr)
-
-       e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
-       e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
-       e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, test2)
-       readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
-       writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
-
-       respBody := ioutil.NopCloser(bytes.NewBufferString(""))
-       url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
-       httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
-
-       notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
-
-       handler.Handle(notificationRequest)
-
-       writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
-       writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
-       httpClientMock.AssertNumberOfCalls(t, "Post", 1)
-}
-
-func TestE2TermInitHandlerSuccessTwoRansFirstRnibInternalErrorFailure(t *testing.T) {
-       _, _, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
-
-       test2 := "test2"
-
-       //First RAN
-       var firstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
-       readerMock.On("GetNodeb", RanName).Return(firstRan, common.NewInternalError(fmt.Errorf("internal error")))
-
-       e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
-       e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
-       e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, test2)
-       readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
-
-       notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
-
-       handler.Handle(notificationRequest)
-
-       writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 0)
-       writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 0)
-       httpClientMock.AssertNumberOfCalls(t, "Post", 0)
-}
-
-func TestE2TermInitHandlerSuccessZeroRans(t *testing.T) {
-       _, handler, _, writerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
-
-       e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
-       e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
-       notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
-
-       handler.Handle(notificationRequest)
-
-       writerMock.AssertNotCalled(t, "UpdateNodebInfo")
-}
-
-func TestE2TermInitHandlerFailureGetNodebInternalError(t *testing.T) {
-       _, handler, readerMock, writerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
-
-       var nodebInfo *entities.NodebInfo
-       readerMock.On("GetNodeb", "test1").Return(nodebInfo, common.NewInternalError(fmt.Errorf("internal error")))
-
-       e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
-       e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, "test1")
-       e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
-       notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
-       handler.Handle(notificationRequest)
-
-       writerMock.AssertNotCalled(t, "UpdateNodebInfo")
-}
-
+//
+//import (
+//     "bytes"
+//     "e2mgr/clients"
+//     "e2mgr/configuration"
+//     "e2mgr/managers"
+//     "e2mgr/mocks"
+//     "e2mgr/models"
+//     "e2mgr/rmrCgo"
+//     "e2mgr/services"
+//     "e2mgr/services/rmrsender"
+//     "e2mgr/tests"
+//     "fmt"
+//     "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
+//     "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
+//     "github.com/pkg/errors"
+//     "github.com/stretchr/testify/mock"
+//     "io/ioutil"
+//     "net/http"
+//     "testing"
+//)
+//
+//const (
+//     e2tInitPayload = "{\"address\":\"10.0.2.15\", \"fqdn\":\"\"}"
+//     e2tInstanceAddress = "10.0.2.15"
+//     podName = "podNAme_test"
+//)
+//
+//func initRanLostConnectionTest(t *testing.T) (*logger.Logger, E2TermInitNotificationHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.E2TInstancesManagerMock, *mocks.RoutingManagerClientMock) {
+//
+//     logger := initLog(t)
+//     config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
+//
+//     readerMock := &mocks.RnibReaderMock{}
+//
+//     writerMock := &mocks.RnibWriterMock{}
+//
+//     routingManagerClientMock := &mocks.RoutingManagerClientMock{}
+//
+//     rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
+//
+//     e2tInstancesManagerMock := &mocks.E2TInstancesManagerMock{}
+//
+//     ranListManager := &mocks.RanListManagerMock{}
+//     ranAlarmService := &mocks.RanAlarmServiceMock{}
+//     ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService,ranListManager, ranAlarmService)
+//     e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManagerMock, routingManagerClientMock, ranConnectStatusChangeManager)
+//
+//     ranDisconnectionManager := managers.NewRanDisconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, e2tAssociationManager, ranConnectStatusChangeManager)
+//     handler := NewE2TermInitNotificationHandler(logger, ranDisconnectionManager, e2tInstancesManagerMock, routingManagerClientMock)
+//
+//     return logger, handler, readerMock, writerMock, e2tInstancesManagerMock, routingManagerClientMock
+//}
+//
+//func initRanLostConnectionTestWithRealE2tInstanceManager(t *testing.T) (*logger.Logger, *configuration.Configuration, E2TermInitNotificationHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.HttpClientMock) {
+//
+//     logger := initLog(t)
+//     config := configuration.ParseConfiguration()
+//
+//     readerMock := &mocks.RnibReaderMock{}
+//
+//     writerMock := &mocks.RnibWriterMock{}
+//     httpClientMock := &mocks.HttpClientMock{}
+//
+//     routingManagerClient := clients.NewRoutingManagerClient(logger, config, httpClientMock)
+//     rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
+//
+//     e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, logger)
+//     ranListManager := managers.NewRanListManager(logger)
+//     ranAlarmService := services.NewRanAlarmService(logger, config)
+//     ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService,ranListManager, ranAlarmService)
+//     e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManager, routingManagerClient, ranConnectStatusChangeManager)
+//     ranDisconnectionManager := managers.NewRanDisconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, e2tAssociationManager, ranConnectStatusChangeManager)
+//     handler := NewE2TermInitNotificationHandler(logger, ranDisconnectionManager, e2tInstancesManager, routingManagerClient)
+//     return logger, config, handler, readerMock, writerMock, httpClientMock
+//}
+//
+//func TestE2TermInitUnmarshalPayloadFailure(t *testing.T) {
+//     _, handler, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
+//     notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte("asd")}
+//     handler.Handle(notificationRequest)
+//     e2tInstancesManagerMock.AssertNotCalled(t, "GetE2TInstance")
+//     e2tInstancesManagerMock.AssertNotCalled(t, "AddE2TInstance")
+//}
+//
+//func TestE2TermInitEmptyE2TAddress(t *testing.T) {
+//     _, handler, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
+//     notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte("{\"address\":\"\"}")}
+//     handler.Handle(notificationRequest)
+//     e2tInstancesManagerMock.AssertNotCalled(t, "GetE2TInstance")
+//     e2tInstancesManagerMock.AssertNotCalled(t, "AddE2TInstance")
+//}
+//
+//func TestE2TermInitGetE2TInstanceFailure(t *testing.T) {
+//     _, handler, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
+//     var e2tInstance *entities.E2TInstance
+//     e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewInternalError(fmt.Errorf("internal error")))
+//     notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
+//     handler.Handle(notificationRequest)
+//     e2tInstancesManagerMock.AssertNotCalled(t, "AddE2TInstance")
+//}
+//
+//func TestE2TermInitGetE2TInstanceDbFailure(t *testing.T) {
+//     _, _, handler, readerMock, writerMock, _ := initRanLostConnectionTestWithRealE2tInstanceManager(t)
+//     var e2tInstance *entities.E2TInstance
+//     readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewInternalError(fmt.Errorf("internal error")))
+//     notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
+//     handler.Handle(notificationRequest)
+//     writerMock.AssertNotCalled(t, "UpdateNodebInfo")
+//}
+//
+//func TestE2TermInitNewE2TInstance(t *testing.T) {
+//     _, config, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
+//     var e2tInstance *entities.E2TInstance
+//
+//     readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewResourceNotFoundError("not found"))
+//     writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
+//
+//     respBody := ioutil.NopCloser(bytes.NewBufferString(""))
+//     url := config.RoutingManager.BaseUrl + clients.AddE2TInstanceApiSuffix
+//     httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
+//
+//     e2tAddresses := []string{}
+//     readerMock.On("GetE2TAddresses").Return(e2tAddresses, common.NewResourceNotFoundError(""))
+//
+//     e2tAddresses = append(e2tAddresses, e2tInstanceAddress)
+//     writerMock.On("SaveE2TAddresses", e2tAddresses).Return(nil)
+//
+//     notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
+//     handler.Handle(notificationRequest)
+//
+//     httpClientMock.AssertCalled(t, "Post", url, mock.Anything, mock.Anything)
+//     writerMock.AssertCalled(t, "SaveE2TInstance", mock.Anything)
+//     writerMock.AssertCalled(t, "SaveE2TAddresses", e2tAddresses)
+//}
+//
+//func TestE2TermInitNewE2TInstance__RoutingManagerError(t *testing.T) {
+//     _, config, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
+//
+//     var e2tInstance *entities.E2TInstance
+//
+//     readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewResourceNotFoundError("not found"))
+//
+//     url := config.RoutingManager.BaseUrl + clients.AddE2TInstanceApiSuffix
+//     httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{}, errors.New("error"))
+//
+//     notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
+//     handler.Handle(notificationRequest)
+//
+//     writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 0)
+//}
+//
+//func TestE2TermInitExistingE2TInstanceNoAssociatedRans(t *testing.T) {
+//     _, handler, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
+//     e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
+//     e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
+//     notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
+//     handler.Handle(notificationRequest)
+//     e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceAddress)
+//}
+//
+//func TestE2TermInitHandlerSuccessOneRan(t *testing.T) {
+//     _, config, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
+//
+//     var rnibErr error
+//     var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
+//     readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
+//
+//     var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
+//     writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
+//
+//     var disconnectedNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
+//     readerMock.On("GetNodeb", RanName).Return(disconnectedNodeb, rnibErr)
+//
+//     var updatedNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: ""}
+//     writerMock.On("UpdateNodebInfo", updatedNodeb).Return(rnibErr)
+//
+//     e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
+//     e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
+//     readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
+//     writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
+//
+//     respBody := ioutil.NopCloser(bytes.NewBufferString(""))
+//     url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
+//     httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
+//
+//     notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
+//
+//     handler.Handle(notificationRequest)
+//
+//     writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
+//     writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
+//     httpClientMock.AssertNumberOfCalls(t, "Post", 1)
+//}
+//
+//func TestE2TermInitHandlerSuccessOneRan_RoutingManagerError(t *testing.T) {
+//     _, config, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
+//
+//     var rnibErr error
+//     var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
+//     readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
+//
+//     var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
+//     writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
+//
+//     var disconnectedNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
+//     readerMock.On("GetNodeb", RanName).Return(disconnectedNodeb, rnibErr)
+//
+//     var updatedNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: ""}
+//     writerMock.On("UpdateNodebInfo", updatedNodeb).Return(rnibErr)
+//
+//     e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
+//     e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
+//     readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
+//     writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
+//
+//     url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
+//     httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{}, errors.New("error"))
+//
+//     notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
+//
+//     handler.Handle(notificationRequest)
+//
+//     writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
+//     writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
+//     httpClientMock.AssertNumberOfCalls(t, "Post", 1)
+//}
+//
+//func TestE2TermInitHandlerSuccessOneRanShuttingdown(t *testing.T) {
+//     _, _, handler, readerMock, writerMock, _ := initRanLostConnectionTestWithRealE2tInstanceManager(t)
+//     var rnibErr error
+//
+//     var initialNodeb = &entities.NodebInfo{RanName: RanName, ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
+//     readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
+//
+//     var argNodeb = &entities.NodebInfo{RanName: RanName, ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
+//     writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
+//
+//     e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
+//     e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
+//     readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
+//     notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
+//
+//     handler.Handle(notificationRequest)
+//
+//     writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
+//}
+//
+//func TestE2TermInitHandlerSuccessOneRan_ToBeDeleted(t *testing.T) {
+//     _, _, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
+//     var rnibErr error
+//
+//     var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
+//     readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
+//
+//     var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
+//     writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
+//
+//     e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
+//     e2tInstance.State = entities.ToBeDeleted
+//     e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
+//
+//     readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
+//     notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
+//
+//     handler.Handle(notificationRequest)
+//
+//     httpClientMock.AssertNotCalled(t, "Post", mock.Anything, mock.Anything, mock.Anything)
+//     writerMock.AssertNotCalled(t, "UpdateNodebInfo")
+//}
+//
+//func TestE2TermInitHandlerSuccessTwoRans(t *testing.T) {
+//
+//     _, config, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
+//
+//     var rnibErr error
+//     test2 := "test2"
+//
+//     //First RAN
+//     var firstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
+//     var disconnectedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
+//     readerMock.On("GetNodeb", RanName).Return(firstRan, rnibErr).Return(disconnectedFirstRan, rnibErr)
+//
+//     var updatedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
+//     writerMock.On("UpdateNodebInfo", updatedFirstRan).Return(rnibErr)
+//
+//     var updatedDisconnectedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: ""}
+//     writerMock.On("UpdateNodebInfo", updatedDisconnectedFirstRan).Return(rnibErr)
+//
+//     //Second RAN
+//     var secondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
+//     var disconnectedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
+//     readerMock.On("GetNodeb", test2).Return(secondRan, rnibErr).Return(disconnectedSecondRan, rnibErr)
+//
+//     var updatedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
+//     writerMock.On("UpdateNodebInfo", updatedSecondRan).Return(rnibErr)
+//
+//     var updatedDisconnectedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: ""}
+//     writerMock.On("UpdateNodebInfo", updatedDisconnectedSecondRan).Return(rnibErr)
+//
+//     e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
+//     e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
+//     e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, test2)
+//     readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
+//     writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
+//
+//     respBody := ioutil.NopCloser(bytes.NewBufferString(""))
+//     url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
+//     httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
+//
+//     notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
+//
+//     handler.Handle(notificationRequest)
+//
+//     writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 4)
+//     writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 2)
+//     httpClientMock.AssertNumberOfCalls(t, "Post", 2)
+//}
+//
+//func TestE2TermInitHandlerSuccessTwoRansSecondRanShutdown(t *testing.T) {
+//     _, config, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
+//
+//     var rnibErr error
+//     test2 := "test2"
+//
+//     //First RAN
+//     var firstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
+//     var disconnectedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
+//     readerMock.On("GetNodeb", RanName).Return(firstRan, rnibErr).Return(disconnectedFirstRan, rnibErr)
+//
+//     var updatedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
+//     writerMock.On("UpdateNodebInfo", updatedFirstRan).Return(rnibErr)
+//
+//     var updatedDisconnectedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: ""}
+//     writerMock.On("UpdateNodebInfo", updatedDisconnectedFirstRan).Return(rnibErr)
+//
+//     //Second RAN
+//     var secondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
+//     readerMock.On("GetNodeb", test2).Return(secondRan, rnibErr)
+//
+//     e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
+//     e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
+//     readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
+//     writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
+//
+//     respBody := ioutil.NopCloser(bytes.NewBufferString(""))
+//     url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
+//     httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
+//
+//     notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
+//
+//     handler.Handle(notificationRequest)
+//
+//     writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
+//     writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
+//     httpClientMock.AssertNumberOfCalls(t, "Post", 1)
+//}
+//
+//func TestE2TermInitHandlerSuccessTwoRansFirstNotFoundFailure(t *testing.T) {
+//     _, config, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
+//
+//     var rnibErr error
+//     test2 := "test2"
+//
+//     //First RAN
+//     var firstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
+//     readerMock.On("GetNodeb", RanName).Return(firstRan, common.NewResourceNotFoundError("not found"))
+//
+//     //Second RAN
+//     var secondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
+//     var disconnectedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
+//     readerMock.On("GetNodeb", test2).Return(secondRan, rnibErr).Return(disconnectedSecondRan, rnibErr)
+//
+//     var updatedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
+//     writerMock.On("UpdateNodebInfo", updatedSecondRan).Return(rnibErr)
+//
+//     var updatedDisconnectedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: ""}
+//     writerMock.On("UpdateNodebInfo", updatedDisconnectedSecondRan).Return(rnibErr)
+//
+//     e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
+//     e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
+//     e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, test2)
+//     readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
+//     writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
+//
+//     respBody := ioutil.NopCloser(bytes.NewBufferString(""))
+//     url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
+//     httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
+//
+//     notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
+//
+//     handler.Handle(notificationRequest)
+//
+//     writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
+//     writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
+//     httpClientMock.AssertNumberOfCalls(t, "Post", 1)
+//}
+//
+//func TestE2TermInitHandlerSuccessTwoRansFirstRnibInternalErrorFailure(t *testing.T) {
+//     _, _, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
+//
+//     test2 := "test2"
+//
+//     //First RAN
+//     var firstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
+//     readerMock.On("GetNodeb", RanName).Return(firstRan, common.NewInternalError(fmt.Errorf("internal error")))
+//
+//     e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
+//     e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
+//     e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, test2)
+//     readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
+//
+//     notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
+//
+//     handler.Handle(notificationRequest)
+//
+//     writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 0)
+//     writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 0)
+//     httpClientMock.AssertNumberOfCalls(t, "Post", 0)
+//}
+//
+//func TestE2TermInitHandlerSuccessZeroRans(t *testing.T) {
+//     _, handler, _, writerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
+//
+//     e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
+//     e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
+//     notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
+//
+//     handler.Handle(notificationRequest)
+//
+//     writerMock.AssertNotCalled(t, "UpdateNodebInfo")
+//}
+//
+//func TestE2TermInitHandlerFailureGetNodebInternalError(t *testing.T) {
+//     _, handler, readerMock, writerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
+//
+//     var nodebInfo *entities.NodebInfo
+//     readerMock.On("GetNodeb", "test1").Return(nodebInfo, common.NewInternalError(fmt.Errorf("internal error")))
+//
+//     e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
+//     e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, "test1")
+//     e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
+//     notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
+//     handler.Handle(notificationRequest)
+//
+//     writerMock.AssertNotCalled(t, "UpdateNodebInfo")
+//}
+//
 // TODO: extract to test_utils
 func initRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
        rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
index 12d4df1..e7d3ce5 100644 (file)
@@ -31,13 +31,13 @@ type RanLostConnectionHandler struct {
        logger                  *logger.Logger
 }
 
-func NewRanLostConnectionHandler(logger *logger.Logger, ranDisconnectionManager managers.IRanDisconnectionManager) RanLostConnectionHandler {
-       return RanLostConnectionHandler{
+func NewRanLostConnectionHandler(logger *logger.Logger, ranDisconnectionManager managers.IRanDisconnectionManager) *RanLostConnectionHandler {
+       return &RanLostConnectionHandler{
                logger:                  logger,
                ranDisconnectionManager: ranDisconnectionManager,
        }
 }
-func (h RanLostConnectionHandler) Handle(request *models.NotificationRequest) {
+func (h *RanLostConnectionHandler) Handle(request *models.NotificationRequest) {
 
        ranName := request.RanName
 
index 933ed92..644ce7a 100644 (file)
@@ -1,4 +1,4 @@
-               //// Copyright 2019 AT&T Intellectual Property
+//// Copyright 2019 AT&T Intellectual Property
 //// Copyright 2019 Nokia
 ////
 //// Licensed under the Apache License, Version 2.0 (the "License");
@@ -29,40 +29,23 @@ import (
        "e2mgr/services"
        "encoding/json"
        "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
-       "github.com/pkg/errors"
        "io/ioutil"
        "net/http"
        "testing"
 )
 
-const ranName = "test"
-const e2tAddress = "10.10.2.15:9800"
-
-func TestLostConnectionHandlerSuccess(t *testing.T) {
-       logger, _ := logger.InitLogger(logger.InfoLevel)
-
-       notificationRequest := models.NotificationRequest{RanName: ranName}
-       ranDisconnectionManagerMock := &mocks.RanDisconnectionManagerMock{}
-       ranDisconnectionManagerMock.On("DisconnectRan", ranName).Return(nil)
-       handler := NewRanLostConnectionHandler(logger, ranDisconnectionManagerMock)
-       handler.Handle(&notificationRequest)
-       ranDisconnectionManagerMock.AssertCalled(t, "DisconnectRan", ranName)
-}
-
-func TestLostConnectionHandlerFailure(t *testing.T) {
-       logger, _ := logger.InitLogger(logger.InfoLevel)
-
-       notificationRequest := models.NotificationRequest{RanName: ranName}
-       ranDisconnectionManagerMock := &mocks.RanDisconnectionManagerMock{}
-       ranDisconnectionManagerMock.On("DisconnectRan", ranName).Return(errors.New("error"))
-       handler := NewRanLostConnectionHandler(logger, ranDisconnectionManagerMock)
-       handler.Handle(&notificationRequest)
-       ranDisconnectionManagerMock.AssertCalled(t, "DisconnectRan", ranName)
-}
+const (
+       ranName    = "test"
+       e2tAddress = "10.10.2.15:9800"
+)
 
-func setupLostConnectionHandlerTestWithRealDisconnectionManager(t *testing.T, isSuccessfulHttpPost bool) (RanLostConnectionHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.HttpClientMock) {
+func setupLostConnectionHandlerTest(isSuccessfulHttpPost bool) (*RanLostConnectionHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.HttpClientMock) {
        logger, _ := logger.InitLogger(logger.InfoLevel)
-       config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
+       config := &configuration.Configuration{
+               RnibRetryIntervalMs:       10,
+               MaxRnibConnectionAttempts: 3,
+               StateChangeMessageChannel: StateChangeMessageChannel,
+       }
 
        readerMock := &mocks.RnibReaderMock{}
        writerMock := &mocks.RnibWriterMock{}
@@ -72,29 +55,12 @@ func setupLostConnectionHandlerTestWithRealDisconnectionManager(t *testing.T, is
        routingManagerClient := clients.NewRoutingManagerClient(logger, config, httpClientMock)
        ranListManager := managers.NewRanListManager(logger)
        ranAlarmService := services.NewRanAlarmService(logger, config)
-       ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService,ranListManager, ranAlarmService)
+       ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService, ranListManager, ranAlarmService)
 
        e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManager, routingManagerClient, ranConnectStatusChangeManager)
-       ranDisconnectionManager := managers.NewRanDisconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, e2tAssociationManager)
+       ranDisconnectionManager := managers.NewRanDisconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, e2tAssociationManager, ranConnectStatusChangeManager)
        handler := NewRanLostConnectionHandler(logger, ranDisconnectionManager)
 
-       origNodebInfo := &entities.NodebInfo{RanName: ranName, GlobalNbId: &entities.GlobalNbId{PlmnId: "xxx", NbId: "yyy"}, ConnectionStatus: entities.ConnectionStatus_CONNECTING, AssociatedE2TInstanceAddress: e2tAddress}
-       var rnibErr error
-       readerMock.On("GetNodeb", ranName).Return(origNodebInfo, rnibErr)
-       updatedNodebInfo1 := *origNodebInfo
-       updatedNodebInfo1.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
-       writerMock.On("UpdateNodebInfo", &updatedNodebInfo1).Return(rnibErr)
-       updatedNodebInfo2 := *origNodebInfo
-       updatedNodebInfo2.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
-       updatedNodebInfo2.AssociatedE2TInstanceAddress = ""
-       writerMock.On("UpdateNodebInfo", &updatedNodebInfo2).Return(rnibErr)
-       e2tInstance := &entities.E2TInstance{Address: e2tAddress, AssociatedRanList: []string{ranName}}
-       readerMock.On("GetE2TInstance", e2tAddress).Return(e2tInstance, nil)
-       e2tInstanceToSave := *e2tInstance
-       e2tInstanceToSave.AssociatedRanList = []string{}
-       writerMock.On("SaveE2TInstance", &e2tInstanceToSave).Return(nil)
-       mockHttpClient(httpClientMock, isSuccessfulHttpPost)
-
        return handler, readerMock, writerMock, httpClientMock
 }
 
@@ -112,24 +78,86 @@ func mockHttpClient(httpClientMock *mocks.HttpClientMock, isSuccessful bool) {
        httpClientMock.On("Post", clients.DissociateRanE2TInstanceApiSuffix, "application/json", body).Return(&http.Response{StatusCode: respStatusCode, Body: respBody}, nil)
 }
 
-func TestLostConnectionHandlerFailureWithRealDisconnectionManager(t *testing.T) {
-       handler, readerMock, writerMock, httpClientMock := setupLostConnectionHandlerTestWithRealDisconnectionManager(t, false)
+func TestLostConnectionHandlerConnectingRanSuccess(t *testing.T) {
+       handler, readerMock, writerMock, httpClientMock := setupLostConnectionHandlerTest(true)
 
+       origNodebInfo := &entities.NodebInfo{RanName: ranName, GlobalNbId: &entities.GlobalNbId{PlmnId: "xxx", NbId: "yyy"}, ConnectionStatus: entities.ConnectionStatus_CONNECTING, AssociatedE2TInstanceAddress: e2tAddress}
+       var rnibErr error
+       readerMock.On("GetNodeb", ranName).Return(origNodebInfo, rnibErr)
+       updatedNodebInfo1 := *origNodebInfo
+       updatedNodebInfo1.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
+       writerMock.On("UpdateNodebInfo", &updatedNodebInfo1).Return(rnibErr)
+       updatedNodebInfo2 := *origNodebInfo
+       updatedNodebInfo2.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
+       updatedNodebInfo2.AssociatedE2TInstanceAddress = ""
+       writerMock.On("UpdateNodebInfo", &updatedNodebInfo2).Return(rnibErr)
+       e2tInstance := &entities.E2TInstance{Address: e2tAddress, AssociatedRanList: []string{ranName}}
+       readerMock.On("GetE2TInstance", e2tAddress).Return(e2tInstance, nil)
+       e2tInstanceToSave := *e2tInstance
+       e2tInstanceToSave.AssociatedRanList = []string{}
+       writerMock.On("SaveE2TInstance", &e2tInstanceToSave).Return(nil)
+       mockHttpClient(httpClientMock, true)
        notificationRequest := models.NotificationRequest{RanName: ranName}
        handler.Handle(&notificationRequest)
-
        readerMock.AssertExpectations(t)
        writerMock.AssertExpectations(t)
        httpClientMock.AssertExpectations(t)
        writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
 }
 
-func TestLostConnectionHandlerSuccessWithRealDisconnectionManager(t *testing.T) {
-       handler, readerMock, writerMock, httpClientMock := setupLostConnectionHandlerTestWithRealDisconnectionManager(t, true)
+func TestLostConnectionHandlerConnectedRanSuccess(t *testing.T) {
+       handler, readerMock, writerMock, httpClientMock := setupLostConnectionHandlerTest(true)
 
+       origNodebInfo := &entities.NodebInfo{
+               RanName:                      ranName,
+               GlobalNbId:                   &entities.GlobalNbId{PlmnId: "xxx", NbId: "yyy"},
+               ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
+               AssociatedE2TInstanceAddress: e2tAddress,
+       }
+       var rnibErr error
+       readerMock.On("GetNodeb", ranName).Return(origNodebInfo, rnibErr)
+       updatedNodebInfo1 := *origNodebInfo
+       updatedNodebInfo1.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
+       writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &updatedNodebInfo1, StateChangeMessageChannel, ranName+"_DISCONNECTED").Return(rnibErr)
+       updatedNodebInfo2 := *origNodebInfo
+       updatedNodebInfo2.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
+       updatedNodebInfo2.AssociatedE2TInstanceAddress = ""
+       writerMock.On("UpdateNodebInfo", &updatedNodebInfo2).Return(rnibErr)
+       e2tInstance := &entities.E2TInstance{Address: e2tAddress, AssociatedRanList: []string{ranName}}
+       readerMock.On("GetE2TInstance", e2tAddress).Return(e2tInstance, nil)
+       e2tInstanceToSave := *e2tInstance
+       e2tInstanceToSave.AssociatedRanList = []string{}
+       writerMock.On("SaveE2TInstance", &e2tInstanceToSave).Return(nil)
+       mockHttpClient(httpClientMock, true)
        notificationRequest := models.NotificationRequest{RanName: ranName}
        handler.Handle(&notificationRequest)
+       readerMock.AssertExpectations(t)
+       writerMock.AssertExpectations(t)
+       httpClientMock.AssertExpectations(t)
+       writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
+}
+
+func TestLostConnectionHandlerRmDissociateFailure(t *testing.T) {
+       handler, readerMock, writerMock, httpClientMock := setupLostConnectionHandlerTest(false)
 
+       origNodebInfo := &entities.NodebInfo{RanName: ranName, GlobalNbId: &entities.GlobalNbId{PlmnId: "xxx", NbId: "yyy"}, ConnectionStatus: entities.ConnectionStatus_CONNECTING, AssociatedE2TInstanceAddress: e2tAddress}
+       var rnibErr error
+       readerMock.On("GetNodeb", ranName).Return(origNodebInfo, rnibErr)
+       updatedNodebInfo1 := *origNodebInfo
+       updatedNodebInfo1.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
+       writerMock.On("UpdateNodebInfo", &updatedNodebInfo1).Return(rnibErr)
+       updatedNodebInfo2 := *origNodebInfo
+       updatedNodebInfo2.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
+       updatedNodebInfo2.AssociatedE2TInstanceAddress = ""
+       writerMock.On("UpdateNodebInfo", &updatedNodebInfo2).Return(rnibErr)
+       e2tInstance := &entities.E2TInstance{Address: e2tAddress, AssociatedRanList: []string{ranName}}
+       readerMock.On("GetE2TInstance", e2tAddress).Return(e2tInstance, nil)
+       e2tInstanceToSave := *e2tInstance
+       e2tInstanceToSave.AssociatedRanList = []string{}
+       writerMock.On("SaveE2TInstance", &e2tInstanceToSave).Return(nil)
+       mockHttpClient(httpClientMock, false)
+       notificationRequest := models.NotificationRequest{RanName: ranName}
+       handler.Handle(&notificationRequest)
        readerMock.AssertExpectations(t)
        writerMock.AssertExpectations(t)
        httpClientMock.AssertExpectations(t)
index 8ed5ec1..dfcaa3d 100644 (file)
@@ -112,6 +112,7 @@ func (m *E2TAssociationManager) DissociateRan(e2tAddress string, ranName string)
        }
 
        err = m.rmClient.DissociateRanE2TInstance(e2tAddress, ranName)
+
        if err != nil {
                m.logger.Errorf("#E2TAssociationManager.DissociateRan - RoutingManager failure: Failed to dissociate RAN %s from E2T %s. Error: %s", ranName, e2tAddress, err)
        } else {
index 982524c..1887cd7 100644 (file)
@@ -399,13 +399,13 @@ func (m *E2TInstancesManager) SetE2tInstanceState(e2tAddress string, currentStat
                return e2managererrors.NewRnibDbError()
        }
 
-       if (currentState != e2tInstance.State) {
+       if currentState != e2tInstance.State {
                m.logger.Warnf("#E2TInstancesManager.SetE2tInstanceState - E2T Instance address: %s - Current state is not: %s", e2tAddress, currentState)
                return e2managererrors.NewInternalError()
        }
 
        e2tInstance.State = newState
-       if (newState == entities.Active) {
+       if newState == entities.Active {
                e2tInstance.KeepAliveTimestamp = time.Now().UnixNano()
        }
 
index 27431a3..3d73bd3 100644 (file)
@@ -46,7 +46,6 @@ func initNotificationManagerTest(t *testing.T) (*logger.Logger, *mocks.RnibReade
 
        rmrSender := initRmrSender(&mocks.RmrMessengerMock{}, logger)
        rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
-       ranSetupManager := managers.NewRanSetupManager(logger, rmrSender, rnibDataService)
        e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, logger)
        routingManagerClient := clients.NewRoutingManagerClient(logger, config, httpClient)
        ranListManager := managers.NewRanListManager(logger)
@@ -54,7 +53,7 @@ func initNotificationManagerTest(t *testing.T) (*logger.Logger, *mocks.RnibReade
        ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService,ranListManager, ranAlarmService)
        e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManager, routingManagerClient, ranConnectStatusChangeManager)
        rmrNotificationHandlerProvider := rmrmsghandlerprovider.NewNotificationHandlerProvider()
-       rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager,routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager)
+       rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, e2tInstancesManager,routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager)
        notificationManager := NewNotificationManager(logger, rmrNotificationHandlerProvider )
        return logger, readerMock, notificationManager
 }
index ce6d62e..aeb91bb 100644 (file)
@@ -31,19 +31,20 @@ type IRanDisconnectionManager interface {
 }
 
 type RanDisconnectionManager struct {
-       logger                *logger.Logger
-       config                *configuration.Configuration
-       rnibDataService       services.RNibDataService
-       ranSetupManager       *RanSetupManager
-       e2tAssociationManager *E2TAssociationManager
+       logger                        *logger.Logger
+       config                        *configuration.Configuration
+       rnibDataService               services.RNibDataService
+       e2tAssociationManager         *E2TAssociationManager
+       ranConnectStatusChangeManager IRanConnectStatusChangeManager
 }
 
-func NewRanDisconnectionManager(logger *logger.Logger, config *configuration.Configuration, rnibDataService services.RNibDataService, e2tAssociationManager *E2TAssociationManager) *RanDisconnectionManager {
+func NewRanDisconnectionManager(logger *logger.Logger, config *configuration.Configuration, rnibDataService services.RNibDataService, e2tAssociationManager *E2TAssociationManager, ranConnectStatusChangeManager IRanConnectStatusChangeManager) *RanDisconnectionManager {
        return &RanDisconnectionManager{
-               logger:                logger,
-               config:                config,
-               rnibDataService:       rnibDataService,
-               e2tAssociationManager: e2tAssociationManager,
+               logger:                        logger,
+               config:                        config,
+               rnibDataService:               rnibDataService,
+               e2tAssociationManager:         e2tAssociationManager,
+               ranConnectStatusChangeManager: ranConnectStatusChangeManager,
        }
 }
 
@@ -58,17 +59,16 @@ func (m *RanDisconnectionManager) DisconnectRan(inventoryName string) error {
        connectionStatus := nodebInfo.GetConnectionStatus()
        m.logger.Infof("#RanDisconnectionManager.DisconnectRan - RAN name: %s - RAN's connection status: %s", nodebInfo.RanName, connectionStatus)
 
-
        if connectionStatus == entities.ConnectionStatus_SHUT_DOWN {
                m.logger.Warnf("#RanDisconnectionManager.DisconnectRan - RAN name: %s - quit. RAN's connection status is SHUT_DOWN", nodebInfo.RanName)
                return nil
        }
 
        if connectionStatus == entities.ConnectionStatus_SHUTTING_DOWN {
-               return m.updateNodebInfo(nodebInfo, entities.ConnectionStatus_SHUT_DOWN)
+               return m.ranConnectStatusChangeManager.ChangeStatus(nodebInfo, entities.ConnectionStatus_SHUT_DOWN)
        }
 
-       err = m.updateNodebInfo(nodebInfo, entities.ConnectionStatus_DISCONNECTED)
+       err = m.ranConnectStatusChangeManager.ChangeStatus(nodebInfo, entities.ConnectionStatus_DISCONNECTED)
 
        if err != nil {
                return err
@@ -80,7 +80,7 @@ func (m *RanDisconnectionManager) DisconnectRan(inventoryName string) error {
 
 func (m *RanDisconnectionManager) updateNodebInfo(nodebInfo *entities.NodebInfo, connectionStatus entities.ConnectionStatus) error {
 
-       nodebInfo.ConnectionStatus = connectionStatus;
+       nodebInfo.ConnectionStatus = connectionStatus
        err := m.rnibDataService.UpdateNodebInfo(nodebInfo)
 
        if err != nil {
index 7c44b80..abc7ffd 100644 (file)
@@ -56,7 +56,7 @@ func initRanLostConnectionTest(t *testing.T) (*logger.Logger, *mocks.RmrMessenge
        ranAlarmService := services.NewRanAlarmService(logger, config)
        ranConnectStatusChangeManager := NewRanConnectStatusChangeManager(logger, rnibDataService,ranListManager, ranAlarmService)
        e2tAssociationManager := NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManager, routingManagerClient, ranConnectStatusChangeManager)
-       ranDisconnectionManager := NewRanDisconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, e2tAssociationManager)
+       ranDisconnectionManager := NewRanDisconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, e2tAssociationManager, ranConnectStatusChangeManager)
        return logger, rmrMessengerMock, readerMock, writerMock, ranDisconnectionManager, httpClient
 }
 
index d32a894..3cd151f 100644 (file)
@@ -50,12 +50,12 @@ type IncomingRequestHandlerProvider struct {
 func NewIncomingRequestHandlerProvider(logger *logger.Logger, rmrSender *rmrsender.RmrSender, config *configuration.Configuration, rNibDataService services.RNibDataService, ranSetupManager *managers.RanSetupManager, e2tInstancesManager managers.IE2TInstancesManager, e2tAssociationManager *managers.E2TAssociationManager, rmClient clients.IRoutingManagerClient) *IncomingRequestHandlerProvider {
 
        return &IncomingRequestHandlerProvider{
-               requestMap: initRequestHandlerMap(logger, rmrSender, config, rNibDataService, ranSetupManager, e2tInstancesManager, e2tAssociationManager, rmClient),
+               requestMap: initRequestHandlerMap(logger, rmrSender, config, rNibDataService, e2tInstancesManager, rmClient),
                logger:     logger,
        }
 }
 
-func initRequestHandlerMap(logger *logger.Logger, rmrSender *rmrsender.RmrSender, config *configuration.Configuration, rNibDataService services.RNibDataService, ranSetupManager *managers.RanSetupManager, e2tInstancesManager managers.IE2TInstancesManager, e2tAssociationManager *managers.E2TAssociationManager, rmClient clients.IRoutingManagerClient) map[IncomingRequest]httpmsghandlers.RequestHandler {
+func initRequestHandlerMap(logger *logger.Logger, rmrSender *rmrsender.RmrSender, config *configuration.Configuration, rNibDataService services.RNibDataService, e2tInstancesManager managers.IE2TInstancesManager, rmClient clients.IRoutingManagerClient) map[IncomingRequest]httpmsghandlers.RequestHandler {
 
        return map[IncomingRequest]httpmsghandlers.RequestHandler{
                ShutdownRequest:                httpmsghandlers.NewDeleteAllRequestHandler(logger, rmrSender, config, rNibDataService, e2tInstancesManager, rmClient),
index 1c14966..1391c32 100644 (file)
@@ -58,9 +58,9 @@ func (provider *NotificationHandlerProvider) Register(msgType int, handler rmrms
 }
 
 func (provider *NotificationHandlerProvider) Init(logger *logger.Logger, config *configuration.Configuration,
-       rnibDataService services.RNibDataService, rmrSender *rmrsender.RmrSender, ranSetupManager *managers.RanSetupManager,
-       e2tInstancesManager managers.IE2TInstancesManager, routingManagerClient clients.IRoutingManagerClient,
-       e2tAssociationManager *managers.E2TAssociationManager, ranConnectStatusChangeManager managers.IRanConnectStatusChangeManager) {
+       rnibDataService services.RNibDataService, rmrSender *rmrsender.RmrSender, e2tInstancesManager managers.IE2TInstancesManager,
+       routingManagerClient clients.IRoutingManagerClient, e2tAssociationManager *managers.E2TAssociationManager,
+       ranConnectStatusChangeManager managers.IRanConnectStatusChangeManager) {
 
        // Init converters
        x2SetupResponseConverter := converters.NewX2SetupResponseConverter(logger)
@@ -71,7 +71,7 @@ func (provider *NotificationHandlerProvider) Init(logger *logger.Logger, config
        x2ResetResponseExtractor := converters.NewX2ResetResponseExtractor(logger)
 
        // Init managers
-       ranReconnectionManager := managers.NewRanDisconnectionManager(logger, config, rnibDataService, e2tAssociationManager)
+       ranReconnectionManager := managers.NewRanDisconnectionManager(logger, config, rnibDataService, e2tAssociationManager, ranConnectStatusChangeManager)
        ranStatusChangeManager := managers.NewRanStatusChangeManager(logger, rmrSender)
        x2SetupResponseManager := managers.NewX2SetupResponseManager(x2SetupResponseConverter)
        x2SetupFailureResponseManager := managers.NewX2SetupFailureResponseManager(x2SetupFailureResponseConverter)
index dc8d99b..0f22280 100644 (file)
@@ -17,7 +17,6 @@
 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
 //  platform project (RICP).
 
-
 package rmrmsghandlerprovider
 
 import (
@@ -42,7 +41,7 @@ import (
  * Verify support for known providers.
  */
 
-func initTestCase(t *testing.T) (*logger.Logger, *configuration.Configuration, services.RNibDataService, *rmrsender.RmrSender, *managers.RanSetupManager, managers.IE2TInstancesManager, clients.IRoutingManagerClient, *managers.E2TAssociationManager, managers.IRanConnectStatusChangeManager) {
+func initTestCase(t *testing.T) (*logger.Logger, *configuration.Configuration, services.RNibDataService, *rmrsender.RmrSender, managers.IE2TInstancesManager, clients.IRoutingManagerClient, *managers.E2TAssociationManager, managers.IRanConnectStatusChangeManager) {
        logger := initLog(t)
        config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
 
@@ -52,22 +51,21 @@ func initTestCase(t *testing.T) (*logger.Logger, *configuration.Configuration, s
 
        rmrSender := initRmrSender(&mocks.RmrMessengerMock{}, logger)
        rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
-       ranSetupManager := managers.NewRanSetupManager(logger, rmrSender, rnibDataService)
        e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, logger)
        routingManagerClient := clients.NewRoutingManagerClient(logger, config, httpClient)
        ranListManager := managers.NewRanListManager(logger)
        ranAlarmService := services.NewRanAlarmService(logger, config)
-       ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService,ranListManager, ranAlarmService)
+       ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService, ranListManager, ranAlarmService)
        e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManager, routingManagerClient, ranConnectStatusChangeManager)
 
-       return logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager
+       return logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager
 }
 
 func TestGetNotificationHandlerSuccess(t *testing.T) {
 
-       logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager := initTestCase(t)
+       logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager := initTestCase(t)
 
-       ranDisconnectionManager := managers.NewRanDisconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, e2tAssociationManager)
+       ranDisconnectionManager := managers.NewRanDisconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, e2tAssociationManager, ranConnectStatusChangeManager)
        ranStatusChangeManager := managers.NewRanStatusChangeManager(logger, rmrSender)
 
        x2SetupResponseConverter := converters.NewX2SetupResponseConverter(logger)
@@ -79,11 +77,9 @@ func TestGetNotificationHandlerSuccess(t *testing.T) {
        endcSetupResponseConverter := converters.NewEndcSetupResponseConverter(logger)
        endcSetupResponseManager := managers.NewEndcSetupResponseManager(endcSetupResponseConverter)
 
-
        endcSetupFailureResponseConverter := converters.NewEndcSetupFailureResponseConverter(logger)
        endcSetupFailureResponseManager := managers.NewEndcSetupFailureResponseManager(endcSetupFailureResponseConverter)
 
-
        var testCases = []struct {
                msgType int
                handler rmrmsghandlers.NotificationHandler
@@ -91,7 +87,7 @@ func TestGetNotificationHandlerSuccess(t *testing.T) {
                {rmrCgo.RIC_X2_SETUP_RESP, rmrmsghandlers.NewSetupResponseNotificationHandler(logger, rnibDataService, x2SetupResponseManager, ranStatusChangeManager, rmrCgo.RIC_X2_SETUP_RESP)},
                {rmrCgo.RIC_X2_SETUP_FAILURE, rmrmsghandlers.NewSetupResponseNotificationHandler(logger, rnibDataService, x2SetupFailureResponseManager, ranStatusChangeManager, rmrCgo.RIC_X2_SETUP_FAILURE)},
                {rmrCgo.RIC_ENDC_X2_SETUP_RESP, rmrmsghandlers.NewSetupResponseNotificationHandler(logger, rnibDataService, endcSetupResponseManager, ranStatusChangeManager, rmrCgo.RIC_ENDC_X2_SETUP_RESP)},
-               {rmrCgo.RIC_ENDC_X2_SETUP_FAILURE, rmrmsghandlers.NewSetupResponseNotificationHandler(logger, rnibDataService, endcSetupFailureResponseManager, ranStatusChangeManager, rmrCgo.RIC_ENDC_X2_SETUP_FAILURE),},
+               {rmrCgo.RIC_ENDC_X2_SETUP_FAILURE, rmrmsghandlers.NewSetupResponseNotificationHandler(logger, rnibDataService, endcSetupFailureResponseManager, ranStatusChangeManager, rmrCgo.RIC_ENDC_X2_SETUP_FAILURE)},
                {rmrCgo.RIC_SCTP_CONNECTION_FAILURE, rmrmsghandlers.NewRanLostConnectionHandler(logger, ranDisconnectionManager)},
                //{rmrCgo.RIC_ENB_LOAD_INFORMATION, rmrmsghandlers.NewEnbLoadInformationNotificationHandler(logger, rnibDataService, converters.NewEnbLoadInformationExtractor(logger))},
                {rmrCgo.RIC_ENB_CONF_UPDATE, rmrmsghandlers.NewX2EnbConfigurationUpdateHandler(logger, rmrSender)},
@@ -105,7 +101,7 @@ func TestGetNotificationHandlerSuccess(t *testing.T) {
        for _, tc := range testCases {
 
                provider := NewNotificationHandlerProvider()
-               provider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager)
+               provider.Init(logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager)
                t.Run(fmt.Sprintf("%d", tc.msgType), func(t *testing.T) {
                        handler, err := provider.GetNotificationHandler(tc.msgType)
                        if err != nil {
@@ -134,9 +130,9 @@ func TestGetNotificationHandlerFailure(t *testing.T) {
        }
        for _, tc := range testCases {
 
-               logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager := initTestCase(t)
+               logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager := initTestCase(t)
                provider := NewNotificationHandlerProvider()
-               provider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager)
+               provider.Init(logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager)
                t.Run(fmt.Sprintf("%d", tc.msgType), func(t *testing.T) {
                        _, err := provider.GetNotificationHandler(tc.msgType)
                        if err == nil {
index d3c45a6..4a196cf 100644 (file)
@@ -17,7 +17,6 @@
 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
 //  platform project (RICP).
 
-
 package rmrreceiver
 
 import (
@@ -69,15 +68,14 @@ func initRmrReceiver(logger *logger.Logger) *RmrReceiver {
        rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
        rmrMessenger := initRmrMessenger(logger)
        rmrSender := rmrsender.NewRmrSender(logger, rmrMessenger)
-       ranSetupManager := managers.NewRanSetupManager(logger, rmrSender, rnibDataService)
        e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, logger)
        routingManagerClient := clients.NewRoutingManagerClient(logger, config, httpClient)
        ranListManager := managers.NewRanListManager(logger)
        ranAlarmService := services.NewRanAlarmService(logger, config)
-       ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService,ranListManager, ranAlarmService)
+       ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService, ranListManager, ranAlarmService)
        e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManager, routingManagerClient, ranConnectStatusChangeManager)
        rmrNotificationHandlerProvider := rmrmsghandlerprovider.NewNotificationHandlerProvider()
-       rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager)
+       rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager)
        notificationManager := notificationmanager.NewNotificationManager(logger, rmrNotificationHandlerProvider)
        return NewRmrReceiver(logger, rmrMessenger, notificationManager)
 }