[RICPLT-2590] Update Red Button Flow with MultiE2T support + UTs

Change-Id: Ib5e27cf36b5c4051dea861fb1d25a67c4ddd8781
Signed-off-by: is005q <idan.shalom@intl.att.com>

diff --git a/.gitignore b/.gitignore
index 0baa305..e6901da 100644 (file)
--- a/.gitignore
+++ b/.gitignore
@@ -5,6 +5,7 @@
 E2Manager/3rdparty/asn1codec/e2ap_engine/converter-example
 E2Manager/3rdparty/asn1codec/tests/
 E2Manager/cp.out
+Automation/Tests/**/*.xml
 __pycache__/ 
 *.html
 *.log
@@ -12,3 +13,5 @@ __pycache__/
 .tox
 docs/_build/
 /.gitreview
+E2Manager/coverage.txt
+E2Manager/e2m

diff --git a/E2Manager/app/main.go b/E2Manager/app/main.go
index 0678611..8eff30d 100644 (file)
--- a/E2Manager/app/main.go
+++ b/E2Manager/app/main.go
@@ -77,7 +77,7 @@ func main() {
        go rmrReceiver.ListenAndHandle()
        go e2tKeepAliveWorker.Execute()
 
-       httpMsgHandlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(logger, rmrSender, config, rnibDataService, ranSetupManager, e2tInstancesManager, e2tAssociationManager)
+       httpMsgHandlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(logger, rmrSender, config, rnibDataService, ranSetupManager, e2tInstancesManager, e2tAssociationManager, routingManagerClient)
        rootController := controllers.NewRootController(rnibDataService)
        nodebController := controllers.NewNodebController(logger, httpMsgHandlerProvider)
        e2tController := controllers.NewE2TController(logger, httpMsgHandlerProvider)

diff --git a/E2Manager/clients/routing_manager_client.go b/E2Manager/clients/routing_manager_client.go
index 5257d04..d4c9bbe 100644 (file)
--- a/E2Manager/clients/routing_manager_client.go
+++ b/E2Manager/clients/routing_manager_client.go
@@ -45,6 +45,7 @@ type IRoutingManagerClient interface {
        AddE2TInstance(e2tAddress string) error
        AssociateRanToE2TInstance(e2tAddress string, ranName string) error
        DissociateRanE2TInstance(e2tAddress string, ranName string) error
+       DissociateAllRans(e2tAddresses []string) error
 }
 
 func NewRoutingManagerClient(logger *logger.Logger, config *configuration.Configuration, httpClient HttpClient) *RoutingManagerClient {

diff --git a/E2Manager/controllers/e2t_controller_test.go b/E2Manager/controllers/e2t_controller_test.go
index 1ed6934..943b138 100644 (file)
--- a/E2Manager/controllers/e2t_controller_test.go
+++ b/E2Manager/controllers/e2t_controller_test.go
@@ -54,7 +54,7 @@ func setupE2TControllerTest(t *testing.T) (*E2TController, *mocks.RnibReaderMock
 
        rnibDataService := services.NewRnibDataService(log, config, readerMock, nil)
        e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, log)
-       handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, nil, config, rnibDataService, nil, e2tInstancesManager, &managers.E2TAssociationManager{})
+       handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, nil, config, rnibDataService, nil, e2tInstancesManager, &managers.E2TAssociationManager{}, nil)
        controller := NewE2TController(log, handlerProvider)
        return controller, readerMock
 }

diff --git a/E2Manager/controllers/nodeb_controller_test.go b/E2Manager/controllers/nodeb_controller_test.go
index e0c392f..726e8c3 100644 (file)
--- a/E2Manager/controllers/nodeb_controller_test.go
+++ b/E2Manager/controllers/nodeb_controller_test.go
@@ -66,7 +66,7 @@ type controllerGetNodebIdListTestContext struct {
        expectedJsonResponse string
 }
 
-func setupControllerTest(t *testing.T) (*NodebController, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock) {
+func  setupControllerTest(t *testing.T) (*NodebController, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock) {
        log := initLog(t)
        config := configuration.ParseConfiguration()
 
@@ -82,7 +82,7 @@ func setupControllerTest(t *testing.T) (*NodebController, *mocks.RnibReaderMock,
        httpClientMock := &mocks.HttpClientMock{}
        rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
        e2tAssociationManager := managers.NewE2TAssociationManager(log, rnibDataService, e2tInstancesManager, rmClient)
-       handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, ranSetupManager, e2tInstancesManager, e2tAssociationManager)
+       handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, ranSetupManager, e2tInstancesManager, e2tAssociationManager, rmClient)
        controller := NewNodebController(log, handlerProvider)
        return controller, readerMock, writerMock, rmrMessengerMock, e2tInstancesManager
 }
@@ -136,7 +136,6 @@ func TestX2SetupSuccess(t *testing.T) {
        assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 }
 
-
 func TestEndcSetupSuccess(t *testing.T) {
 
        controller, readerMock, writerMock, rmrMessengerMock, _ := setupControllerTest(t)
@@ -169,11 +168,8 @@ func TestEndcSetupSuccess(t *testing.T) {
 }
 
 func TestShutdownHandlerRnibError(t *testing.T) {
-       controller, readerMock, _, _, _ := setupControllerTest(t)
-
-       rnibErr := &common.ResourceNotFoundError{}
-       var nbIdentityList []*entities.NbIdentity
-       readerMock.On("GetListNodebIds").Return(nbIdentityList, rnibErr)
+       controller, _, _, _, e2tInstancesManagerMock:= setupControllerTest(t)
+       e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, e2managererrors.NewRnibDbError())
 
        writer := httptest.NewRecorder()
 
@@ -312,11 +308,9 @@ func TestHeaderValidationFailed(t *testing.T) {
 }
 
 func TestShutdownStatusNoContent(t *testing.T) {
-       controller, readerMock, _, _, _ := setupControllerTest(t)
-
-       var rnibError error
-       nbIdentityList := []*entities.NbIdentity{}
-       readerMock.On("GetListNodebIds").Return(nbIdentityList, rnibError)
+       controller, readerMock, _, _, e2tInstancesManagerMock := setupControllerTest(t)
+       e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, nil)
+       readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, nil)
 
        writer := httptest.NewRecorder()
        controller.Shutdown(writer, tests.GetHttpRequest())

diff --git a/E2Manager/handlers/httpmsghandlers/delete_all_request_handler.go b/E2Manager/handlers/httpmsghandlers/delete_all_request_handler.go
index eb238cc..7edc13c 100644 (file)
--- a/E2Manager/handlers/httpmsghandlers/delete_all_request_handler.go
+++ b/E2Manager/handlers/httpmsghandlers/delete_all_request_handler.go
@@ -17,161 +17,163 @@
 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
 //  platform project (RICP).
 
-
 package httpmsghandlers
 
 import "C"
 import (
+       "e2mgr/clients"
        "e2mgr/configuration"
        "e2mgr/e2managererrors"
        "e2mgr/logger"
+       "e2mgr/managers"
        "e2mgr/models"
        "e2mgr/rmrCgo"
        "e2mgr/services"
        "e2mgr/services/rmrsender"
-       "e2mgr/stateMachine"
        "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
        "time"
 )
 
 type DeleteAllRequestHandler struct {
-       rnibDataService services.RNibDataService
-       rmrSender       *rmrsender.RmrSender
-       config          *configuration.Configuration
-       logger          *logger.Logger
+       rnibDataService     services.RNibDataService
+       rmrSender           *rmrsender.RmrSender
+       config              *configuration.Configuration
+       logger              *logger.Logger
+       e2tInstancesManager managers.IE2TInstancesManager
+       rmClient            clients.IRoutingManagerClient
 }
 
-func NewDeleteAllRequestHandler(logger *logger.Logger, rmrSender *rmrsender.RmrSender, config *configuration.Configuration, rnibDataService services.RNibDataService) *DeleteAllRequestHandler {
+func NewDeleteAllRequestHandler(logger *logger.Logger, rmrSender *rmrsender.RmrSender, config *configuration.Configuration, rnibDataService services.RNibDataService, e2tInstancesManager managers.IE2TInstancesManager, rmClient clients.IRoutingManagerClient) *DeleteAllRequestHandler {
        return &DeleteAllRequestHandler{
-               logger:          logger,
-               rnibDataService: rnibDataService,
-               rmrSender:       rmrSender,
-               config:          config,
+               logger:              logger,
+               rnibDataService:     rnibDataService,
+               rmrSender:           rmrSender,
+               config:              config,
+               e2tInstancesManager: e2tInstancesManager,
+               rmClient:            rmClient,
        }
 }
 
-func (handler *DeleteAllRequestHandler) Handle(request models.Request) (models.IResponse, error) {
+func (h *DeleteAllRequestHandler) Handle(request models.Request) (models.IResponse, error) {
+
+       e2tAddresses, err := h.e2tInstancesManager.GetE2TAddresses()
 
-       err, continueFlow := handler.updateNodebStates(false)
        if err != nil {
                return nil, err
        }
 
-       if continueFlow == false {
-               return nil, nil
+       if len(e2tAddresses) == 0 {
+               err, _ = h.updateNodebs(h.updateNodebInfoForceShutdown)
+               return nil, err
        }
 
-       response := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
-       if err := handler.rmrSender.Send(&response); err != nil {
-               handler.logger.Errorf("#DeleteAllRequestHandler.Handle - failed to send sctp clear all message to RMR: %s", err)
-               return nil, e2managererrors.NewRmrError()
+       err = h.rmClient.DissociateAllRans(e2tAddresses)
+
+       if err != nil {
+               h.logger.Warnf("#DeleteAllRequestHandler.Handle - routing manager failure. continue flow.")
+       }
+
+       err, allRansAreShutDown := h.updateNodebs(h.updateNodebInfoShuttingDown)
+
+       if err != nil {
+               return nil, err
        }
 
-       time.Sleep(time.Duration(handler.config.BigRedButtonTimeoutSec) * time.Second)
-       handler.logger.Infof("#DeleteAllRequestHandler.Handle - timer expired")
+       err = h.e2tInstancesManager.ClearRansOfAllE2TInstances()
 
-       err, _ = handler.updateNodebStates(true)
        if err != nil {
                return nil, err
        }
 
-       return nil, nil
+       rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
+
+       err = h.rmrSender.Send(&rmrMessage)
+
+       if err != nil {
+               h.logger.Errorf("#DeleteAllRequestHandler.Handle - failed to send sctp clear all message to RMR: %s", err)
+               return nil, e2managererrors.NewRmrError()
+       }
+
+       if allRansAreShutDown {
+               return nil, nil
+       }
+
+       time.Sleep(time.Duration(h.config.BigRedButtonTimeoutSec) * time.Second)
+       h.logger.Infof("#DeleteAllRequestHandler.Handle - timer expired")
+
+       err, _ = h.updateNodebs(h.updateNodebInfoShutDown)
+       return nil, err
 }
 
-func (handler *DeleteAllRequestHandler) updateNodebStates(timeoutExpired bool) (error, bool) {
-       nbIdentityList, err := handler.rnibDataService.GetListNodebIds()
+func (h *DeleteAllRequestHandler) updateNodebs(updateCb func(node *entities.NodebInfo) error) (error, bool) {
+       nbIdentityList, err := h.rnibDataService.GetListNodebIds()
 
        if err != nil {
-               handler.logger.Errorf("#DeleteAllRequestHandler.updateNodebStates - failed to get nodes list from RNIB. Error: %s", err.Error())
+               h.logger.Errorf("#DeleteAllRequestHandler.updateNodebs - failed to get nodes list from rNib. Error: %s", err)
                return e2managererrors.NewRnibDbError(), false
        }
 
-       if len(nbIdentityList) == 0 {
-               return nil, false
-       }
+       allRansAreShutdown := true
 
-       numOfRanToShutDown := 0
        for _, nbIdentity := range nbIdentityList {
-
-               node, err := handler.rnibDataService.GetNodeb((*nbIdentity).GetInventoryName())
+               node, err := h.rnibDataService.GetNodeb(nbIdentity.InventoryName)
 
                if err != nil {
-                       handler.logger.Errorf("#DeleteAllRequestHandler.updateNodebStates - failed to get nodeB entity for ran name: %v from RNIB. Error: %s",
-                               (*nbIdentity).GetInventoryName(), err.Error())
+                       h.logger.Errorf("#DeleteAllRequestHandler.updateNodebs - failed to get nodeB entity for ran name: %s from rNib. error: %s", nbIdentity.InventoryName, err)
                        continue
                }
 
-               if timeoutExpired {
-
-                       if handler.saveNodebShutDownState(nbIdentity, node) {
-                               numOfRanToShutDown++
-                       }
-                       continue
+               if node.ConnectionStatus != entities.ConnectionStatus_SHUT_DOWN {
+                       allRansAreShutdown = false
                }
-               if handler.saveNodebNextState(nbIdentity, node) {
-                       numOfRanToShutDown++
-               }
-       }
 
-       if numOfRanToShutDown > 0 {
-               handler.logger.Infof("#DeleteAllRequestHandler.updateNodebStates - update nodebs states in RNIB completed")
-       } else {
-               handler.logger.Infof("#DeleteAllRequestHandler.updateNodebStates - nodebs states are not updated ")
-               return nil, false
+               _ = updateCb(node)
        }
 
-       return nil, true
-}
-
-func (handler *DeleteAllRequestHandler) saveNodebNextState(nbIdentity *entities.NbIdentity, node *entities.NodebInfo) bool {
-
-       if node.ConnectionStatus == entities.ConnectionStatus_SHUTTING_DOWN {
-               return true
-       }
-
-       nextStatus, res := stateMachine.NodeNextStateDeleteAll(node.ConnectionStatus)
-       if res == false {
-               return false
-       }
+       return nil, allRansAreShutdown
 
-       node.ConnectionStatus = nextStatus
+}
 
-       err := handler.rnibDataService.SaveNodeb(nbIdentity, node)
+func (h *DeleteAllRequestHandler) updateNodebInfoForceShutdown(node *entities.NodebInfo) error {
+       return h.updateNodebInfo(node, entities.ConnectionStatus_SHUT_DOWN, true)
+}
 
-       if err != nil {
-               handler.logger.Errorf("#DeleteAllRequestHandler.saveNodebNextState - failed to save nodeB entity for inventory name: %v to RNIB. Error: %s",
-                       (*nbIdentity).GetInventoryName(), err.Error())
-               return false
+func (h *DeleteAllRequestHandler) updateNodebInfoShuttingDown(node *entities.NodebInfo) error {
+       if node.ConnectionStatus == entities.ConnectionStatus_SHUT_DOWN {
+               return nil
        }
 
-       if handler.logger.DebugEnabled() {
-               handler.logger.Debugf("#DeleteAllRequestHandler.saveNodebNextState - connection status of inventory name: %v changed to %v",
-                       (*nbIdentity).GetInventoryName(), nextStatus.String())
-       }
-       return true
+       return h.updateNodebInfo(node, entities.ConnectionStatus_SHUTTING_DOWN, true)
 }
 
-func (handler *DeleteAllRequestHandler) saveNodebShutDownState(nbIdentity *entities.NbIdentity, node *entities.NodebInfo) bool {
-
+func (h *DeleteAllRequestHandler) updateNodebInfoShutDown(node *entities.NodebInfo) error {
        if node.ConnectionStatus == entities.ConnectionStatus_SHUT_DOWN {
-               return false
+               return nil
        }
 
        if node.ConnectionStatus != entities.ConnectionStatus_SHUTTING_DOWN {
-               handler.logger.Errorf("#DeleteAllRequestHandler.saveNodebShutDownState - ignore, status is not Shutting Down, inventory name: %v ", (*nbIdentity).GetInventoryName())
-               return false
+               h.logger.Warnf("#DeleteAllRequestHandler.updateNodebInfoShutDown - RAN name: %s - ignore, status is not Shutting Down", node.RanName)
+               return nil
        }
 
-       node.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
+       return h.updateNodebInfo(node, entities.ConnectionStatus_SHUT_DOWN, false)
+}
+
+func (h *DeleteAllRequestHandler) updateNodebInfo(node *entities.NodebInfo, connectionStatus entities.ConnectionStatus, resetAssociatedE2TAddress bool) error {
+       node.ConnectionStatus = connectionStatus
 
-       err := handler.rnibDataService.SaveNodeb(nbIdentity, node)
+       if resetAssociatedE2TAddress {
+               node.AssociatedE2TInstanceAddress = ""
+       }
+
+       err := h.rnibDataService.UpdateNodebInfo(node)
 
        if err != nil {
-               handler.logger.Errorf("#DeleteAllRequestHandler.saveNodebShutDownState - failed to save nodeB entity for inventory name: %v to RNIB. Error: %s",
-                       (*nbIdentity).GetInventoryName(), err.Error())
-               return false
+               h.logger.Errorf("#DeleteAllRequestHandler.updateNodebInfo - RAN name: %s - failed saving nodeB entity to rNib. error: %s", node.RanName, err)
+               return err
        }
 
-       handler.logger.Errorf("#DeleteAllRequestHandler.saveNodebShutDownState - Shut Down , inventory name: %v ", (*nbIdentity).GetInventoryName())
-       return true
+       h.logger.Infof("#DeleteAllRequestHandler.updateNodebInfo - RAN name: %s, connection status: %s", node.RanName, connectionStatus)
+       return nil
+
 }

diff --git a/E2Manager/handlers/httpmsghandlers/delete_all_request_handler_test.go b/E2Manager/handlers/httpmsghandlers/delete_all_request_handler_test.go
index 956a366..5332bd9 100644 (file)
--- a/E2Manager/handlers/httpmsghandlers/delete_all_request_handler_test.go
+++ b/E2Manager/handlers/httpmsghandlers/delete_all_request_handler_test.go
@@ -17,365 +17,392 @@
 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
 //  platform project (RICP).
 
-
 package httpmsghandlers
 
 import (
+       "bytes"
+       "e2mgr/clients"
        "e2mgr/configuration"
        "e2mgr/e2managererrors"
        "e2mgr/logger"
+       "e2mgr/managers"
        "e2mgr/mocks"
+       "e2mgr/models"
        "e2mgr/rmrCgo"
        "e2mgr/services"
        "e2mgr/services/rmrsender"
        "e2mgr/tests"
-       "fmt"
+       "encoding/json"
        "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/assert"
-       "github.com/stretchr/testify/mock"
-       "reflect"
+       "io/ioutil"
+       "net/http"
        "testing"
 )
 
-func setupTest(t *testing.T) (*logger.Logger, *configuration.Configuration, *mocks.RnibReaderMock, *mocks.RnibWriterMock, services.RNibDataService, *mocks.RmrMessengerMock) {
+func setupDeleteAllRequestHandlerTest(t *testing.T) (*DeleteAllRequestHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.HttpClientMock) {
        log := initLog(t)
        config := configuration.ParseConfiguration()
+       config.BigRedButtonTimeoutSec = 1
+       config.RoutingManager.BaseUrl = BaseRMUrl
 
        readerMock := &mocks.RnibReaderMock{}
-
        writerMock := &mocks.RnibWriterMock{}
-
        rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
+
        rmrMessengerMock := &mocks.RmrMessengerMock{}
-       return log, config, readerMock, writerMock, rnibDataService, rmrMessengerMock
+       rmrSender := getRmrSender(rmrMessengerMock, log)
+
+       e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, log)
+       httpClientMock := &mocks.HttpClientMock{}
+       rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
+       handler := NewDeleteAllRequestHandler(log, rmrSender, config, rnibDataService, e2tInstancesManager, rmClient)
+       return handler, readerMock, writerMock, rmrMessengerMock, httpClientMock
 }
 
-func TestHandleBeforeTimerGetListNodebIdsFailedFlow(t *testing.T) {
-       log, config, readerMock, _, rnibDataService, rmrMessengerMock := setupTest(t)
+func mapE2TAddressesToE2DataList(e2tAddresses []string) models.RoutingManagerE2TDataList {
+       e2tDataList := make(models.RoutingManagerE2TDataList, len(e2tAddresses))
 
-       handler := NewDeleteAllRequestHandler(log, getRmrSender(rmrMessengerMock, log), config, rnibDataService)
+       for i, v := range e2tAddresses {
+               e2tDataList[i] = models.NewRoutingManagerE2TData(v)
+       }
 
-       rnibErr := &common.ResourceNotFoundError{}
-       var nbIdentityList []*entities.NbIdentity
-       readerMock.On("GetListNodebIds").Return(nbIdentityList, rnibErr)
+       return e2tDataList
+}
 
-       expected := &e2managererrors.RnibDbError{}
-       _, actual := handler.Handle(nil)
-       if reflect.TypeOf(actual) != reflect.TypeOf(expected) {
-               t.Errorf("Error actual = %v, and Expected = %v.", actual, expected)
+func mockHttpClientDissociateAllRans(httpClientMock *mocks.HttpClientMock, e2tAddresses []string, ok bool) {
+       data := mapE2TAddressesToE2DataList(e2tAddresses)
+       marshaled, _ := json.Marshal(data)
+       body := bytes.NewBuffer(marshaled)
+       url := BaseRMUrl + clients.DissociateRanE2TInstanceApiSuffix
+       respBody := ioutil.NopCloser(bytes.NewBufferString(""))
+
+       var status int
+       if ok {
+               status = http.StatusOK
+       } else {
+               status = http.StatusBadRequest
        }
+       httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{StatusCode: status, Body: respBody}, nil)
 }
 
-func TestHandleAfterTimerGetListNodebIdsFailedFlow(t *testing.T) {
-       log, config, readerMock, writerMock, rnibDataService, rmrMessengerMock := setupTest(t)
-
-       config.BigRedButtonTimeoutSec = 1
-
-       handler := NewDeleteAllRequestHandler(log, getRmrSender(rmrMessengerMock, log), config, rnibDataService)
-
-       rnibErr := &common.ResourceNotFoundError{}
-       //Before timer: Disconnected->ShutDown, ShuttingDown->Ignore, Connected->ShuttingDown
-       nbIdentityList := createIdentityList()
-
-       readerMock.On("GetListNodebIds").Return(nbIdentityList, nil).Return(nbIdentityList, rnibErr)
+func TestGetE2TAddressesFailure(t *testing.T) {
+       h, readerMock, _, _, _ := setupDeleteAllRequestHandlerTest(t)
+       readerMock.On("GetE2TAddresses").Return([]string{}, e2managererrors.NewRnibDbError())
+       _, err := h.Handle(nil)
+       assert.IsType(t, &e2managererrors.RnibDbError{}, err)
+       readerMock.AssertExpectations(t)
+}
 
+func TestOneRanGetE2TAddressesEmptyList(t *testing.T) {
+       h, readerMock, writerMock, _, _ := setupDeleteAllRequestHandlerTest(t)
+       readerMock.On("GetE2TAddresses").Return([]string{}, nil)
+       nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
+       readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
        nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
-       nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
-       nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_CONNECTED,}
        readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
-       readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
-       readerMock.On("GetNodeb", "RanName_3").Return(nb3, nil)
-
        updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
-       updatedNb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
-       writerMock.On("SaveNodeb", mock.Anything, updatedNb1).Return(nil)
-       writerMock.On("SaveNodeb", mock.Anything, updatedNb3).Return(nil)
-
-       expected := &e2managererrors.RnibDbError{}
-       _, actual := handler.Handle(nil)
-
-       if reflect.TypeOf(actual) != reflect.TypeOf(expected) {
-               t.Errorf("Error actual = %v, and Expected = %v.", actual, expected)
-       }
+       writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
+       _, err := h.Handle(nil)
+       assert.Nil(t, err)
+       readerMock.AssertExpectations(t)
+       writerMock.AssertExpectations(t)
 }
 
-func TestHandleSuccessFlow(t *testing.T) {
-       log, config, readerMock, writerMock, rnibDataService, rmrMessengerMock := setupTest(t)
-
-       config.BigRedButtonTimeoutSec = 1
-       handler := NewDeleteAllRequestHandler(log, getRmrSender(rmrMessengerMock, log), config, rnibDataService)
-
-       //Before timer: Disconnected->ShutDown, ShuttingDown->Ignore, Connected->ShuttingDown
-       nbIdentityList := createIdentityList()
+func TestTwoRansGetE2TAddressesEmptyListOneGetNodebFailure(t *testing.T) {
+       h, readerMock, writerMock, _, _ := setupDeleteAllRequestHandlerTest(t)
+       readerMock.On("GetE2TAddresses").Return([]string{}, nil)
+       nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}}
        readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
-
        nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
-       nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
-       nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_CONNECTED,}
        readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
-       readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
-       readerMock.On("GetNodeb", "RanName_3").Return(nb3, nil)
-
        updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
-       updatedNb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
-       writerMock.On("SaveNodeb", mock.Anything, updatedNb1).Return(nil)
-       writerMock.On("SaveNodeb", mock.Anything, updatedNb3).Return(nil)
+       writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
+       var nb2 *entities.NodebInfo
+       readerMock.On("GetNodeb", "RanName_2").Return(nb2, common.NewInternalError(errors.New("error")))
+       _, err := h.Handle(nil)
+       assert.Nil(t, err)
+       writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
+       readerMock.AssertExpectations(t)
+}
 
-       //after timer: ShutDown->Ignore, ShuttingDown->ShutDown
+func TestTwoRansGetE2TAddressesEmptyListOneUpdateNodebInfoFailure(t *testing.T) {
+       h, readerMock, writerMock, _, _ := setupDeleteAllRequestHandlerTest(t)
+       readerMock.On("GetE2TAddresses").Return([]string{}, nil)
+       nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}}
        readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 
-       nb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
-       nb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
-       nb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
-       readerMock.On("GetNodeb", "RanName_1").Return(nb1AfterTimer, nil)
-       readerMock.On("GetNodeb", "RanName_2").Return(nb2AfterTimer, nil)
-       readerMock.On("GetNodeb", "RanName_3").Return(nb3AfterTimer, nil)
-
-       updatedNb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
-       updatedNb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
-       writerMock.On("SaveNodeb", mock.Anything, updatedNb2AfterTimer).Return(nil)
-       writerMock.On("SaveNodeb", mock.Anything, updatedNb3AfterTimer).Return(nil)
-
-       mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
-       rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), true).Return(mbuf, nil)
+       nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
+       readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
+       updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
+       writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 
-       _, actual := handler.Handle(nil)
+       nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
+       readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
+       updatedNb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
+       writerMock.On("UpdateNodebInfo", updatedNb2).Return(common.NewInternalError(errors.New("error")))
+       _, err := h.Handle(nil)
+       assert.Nil(t, err)
+       readerMock.AssertExpectations(t)
+       writerMock.AssertExpectations(t)
+}
 
-       assert.Nil(t, actual)
+func TestOneRanDissociateSucceedsTryShuttingDownFailure(t *testing.T) {
+       h, readerMock, writerMock, _, httpClientMock := setupDeleteAllRequestHandlerTest(t)
+       e2tAddresses := []string{E2TAddress}
+       readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
+       mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
+       nbIdentityList := []*entities.NbIdentity{}
+       readerMock.On("GetListNodebIds").Return(nbIdentityList, common.NewInternalError(errors.New("error")))
+       _, err := h.Handle(nil)
+       assert.IsType(t, &e2managererrors.RnibDbError{}, err)
+       readerMock.AssertExpectations(t)
+       writerMock.AssertExpectations(t)
 }
 
-func TestHandleSuccessGetNextStatusFlow(t *testing.T) {
-       log, config, readerMock, writerMock, rnibDataService, rmrMessengerMock := setupTest(t)
+func TestOneRanDissociateFailsTryShuttingDownFailure(t *testing.T) {
+       h, readerMock, writerMock, _, httpClientMock := setupDeleteAllRequestHandlerTest(t)
+       e2tAddresses := []string{E2TAddress}
 
-       config.BigRedButtonTimeoutSec = 1
-       handler := NewDeleteAllRequestHandler(log, getRmrSender(rmrMessengerMock, log), config, rnibDataService)
+       readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
+       mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, false)
+       nbIdentityList := []*entities.NbIdentity{}
+       readerMock.On("GetListNodebIds").Return(nbIdentityList, common.NewInternalError(errors.New("error")))
+       _, err := h.Handle(nil)
+       assert.IsType(t, &e2managererrors.RnibDbError{}, err)
+       readerMock.AssertExpectations(t)
+       writerMock.AssertExpectations(t)
+}
 
+func TestOneRanTryShuttingDownSucceedsClearFails(t *testing.T) {
+       h, readerMock, writerMock, _, httpClientMock := setupDeleteAllRequestHandlerTest(t)
+       e2tAddresses := []string{E2TAddress}
+       readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
+       mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
        nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
        readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
-
-       nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED,}
+       nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
        readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
-
        updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
-       writerMock.On("SaveNodeb", mock.Anything, updatedNb1).Return(nil)
-
-       //after timer: ShutDown->Ignore, ShuttingDown->ShutDown
-       readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
-
-       nb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
-       readerMock.On("GetNodeb", "RanName_1").Return(nb1AfterTimer, nil)
-
-       updatedNb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
-       writerMock.On("SaveNodeb", mock.Anything, updatedNb1AfterTimer).Return(nil)
-
-       mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
-       rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), true).Return(mbuf, nil)
-
-       _, actual := handler.Handle(nil)
-
-       assert.Nil(t, actual)
+       writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
+       readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
+       readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{}, common.NewInternalError(errors.New("error")))
+       _, err := h.Handle(nil)
+       assert.IsType(t, &e2managererrors.RnibDbError{}, err)
+       readerMock.AssertExpectations(t)
+       writerMock.AssertExpectations(t)
 }
 
-func TestHandleShuttingDownStatusFlow(t *testing.T) {
-       log, config, readerMock, writerMock, rnibDataService, rmrMessengerMock := setupTest(t)
-
-       config.BigRedButtonTimeoutSec = 1
-       handler := NewDeleteAllRequestHandler(log, getRmrSender(rmrMessengerMock, log), config, rnibDataService)
-
+func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSendFails(t *testing.T) {
+       h, readerMock, writerMock, rmrMessengerMock, httpClientMock := setupDeleteAllRequestHandlerTest(t)
+       e2tAddresses := []string{E2TAddress}
+       readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
+       mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
        nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
        readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
-
-       nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
+       nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
        readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
-
-       //after timer: ShutDown->Ignore, ShuttingDown->ShutDown
-       readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
-
-       nb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
-       readerMock.On("GetNodeb", "RanName_1").Return(nb1AfterTimer, nil)
-
-       updatedNb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
-       writerMock.On("SaveNodeb", mock.Anything, updatedNb1AfterTimer).Return(nil)
-
-       mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
-       rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), true).Return(mbuf, nil)
-
-       _, actual := handler.Handle(nil)
-
-       assert.Nil(t, actual)
+       updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
+       writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
+       readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
+       e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1"}}
+       readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
+       updatedE2tInstance := e2tInstance
+       updatedE2tInstance.AssociatedRanList = []string{}
+       writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
+
+       rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
+       mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction)
+       rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, e2managererrors.NewRmrError())
+       _, err := h.Handle(nil)
+       assert.IsType(t, &e2managererrors.RmrError{}, err)
+       rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
+       readerMock.AssertExpectations(t)
+       writerMock.AssertExpectations(t)
 }
 
-func TestHandleGetNodebFailedFlow(t *testing.T) {
-       log, config, readerMock, writerMock, rnibDataService, rmrMessengerMock := setupTest(t)
-
-       config.BigRedButtonTimeoutSec = 1
-       handler := NewDeleteAllRequestHandler(log, getRmrSender(rmrMessengerMock, log), config, rnibDataService)
-
-       //Before timer: Disconnected->ShutDown(will fail), ShuttingDown->Ignore, Connected->ShuttingDown
-       nbIdentityList := createIdentityList()
+func TestTwoRansTryShuttingDownSucceedsClearSucceedsRmrSucceedsAllRansAreShutdown(t *testing.T) {
+       h, readerMock, writerMock, rmrMessengerMock, httpClientMock := setupDeleteAllRequestHandlerTest(t)
+       e2tAddresses := []string{E2TAddress}
+       readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
+       mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
+       nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}}
        readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
-
-       errRnib := &common.ResourceNotFoundError{}
-       nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
-       nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
-       nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_CONNECTED,}
-       readerMock.On("GetNodeb", "RanName_1").Return(nb1, errRnib)
+       nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
+       nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
+       readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
        readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
-       readerMock.On("GetNodeb", "RanName_3").Return(nb3, nil)
-
-       updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
-       updatedNb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
-       writerMock.On("SaveNodeb", mock.Anything, updatedNb1).Return(errRnib)
-       writerMock.On("SaveNodeb", mock.Anything, updatedNb3).Return(nil)
-
-       //after timer: ShutDown->Ignore, ShuttingDown->ShutDown
-       readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
-
-       nb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
-       nb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
-       nb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
-       readerMock.On("GetNodeb", "RanName_1").Return(nb1AfterTimer, errRnib)
-       readerMock.On("GetNodeb", "RanName_2").Return(nb2AfterTimer, nil)
-       readerMock.On("GetNodeb", "RanName_3").Return(nb3AfterTimer, nil)
-
-       updatedNb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
-       updatedNb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
-       writerMock.On("SaveNodeb", mock.Anything, updatedNb2AfterTimer).Return(nil)
-       writerMock.On("SaveNodeb", mock.Anything, updatedNb3AfterTimer).Return(nil)
-
-       mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
-       rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), true).Return(mbuf, nil)
-
-       _, actual := handler.Handle(nil)
-
-       assert.Nil(t, actual)
+       readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
+       e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1", "RanName_2"}}
+       readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
+       updatedE2tInstance := e2tInstance
+       updatedE2tInstance.AssociatedRanList = []string{}
+       writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
+
+       rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
+       mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction)
+       rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
+       _, err := h.Handle(nil)
+       assert.Nil(t, err)
+       rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
+       readerMock.AssertExpectations(t)
+       writerMock.AssertExpectations(t)
 }
 
-func TestHandleSaveFailedFlow(t *testing.T) {
-       log, config, readerMock, writerMock, rnibDataService, rmrMessengerMock := setupTest(t)
-
-       config.BigRedButtonTimeoutSec = 1
-       handler := NewDeleteAllRequestHandler(log, getRmrSender(rmrMessengerMock, log), config, rnibDataService)
-
-       //Before timer: Disconnected->ShutDown, ShuttingDown->Ignore, Connected->ShuttingDown(will fail)
-       nbIdentityList := createIdentityList()
+//func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsAlreadyShutdown(t *testing.T) {
+//     h, readerMock, writerMock, rmrMessengerMock, httpClientMock := setupDeleteAllRequestHandlerTest(t)
+//     e2tAddresses := []string{E2TAddress}
+
+//     readerMock.On("GetE2TAddresses").Return(e2tAddresses , nil)
+//     mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses ,true)
+//     nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
+//     readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
+//     nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
+//     readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
+//     updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
+//     writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
+//     readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
+//     e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1"}}
+//     readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance }, nil)
+//     updatedE2tInstance := e2tInstance
+//     updatedE2tInstance.AssociatedRanList = []string{}
+//     writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
+//
+//     rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
+//     mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction)
+//     rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
+//
+//     readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
+//     nbAfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
+//     readerMock.On("GetNodeb", /*"RanName_1"*/mock.Anything).Return(nbAfterTimer , nil) // Since this is a second call with same arguments we send mock.Anything due to mock limitations
+//     _, err := h.Handle(nil)
+//     assert.Nil(t, err)
+//     rmrMessengerMock.AssertCalled(t, "SendMsg",mbuf, true)
+//     readerMock.AssertExpectations(t)
+//     writerMock.AssertExpectations(t)
+//     writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
+//}
+
+func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDown(t *testing.T) {
+       h, readerMock, writerMock, rmrMessengerMock, httpClientMock := setupDeleteAllRequestHandlerTest(t)
+       e2tAddresses := []string{E2TAddress}
+       readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
+       mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
+       nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
        readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
+       //nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
+       //readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
+       updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
+       writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
+       readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
+       e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1"}}
+       readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
+       updatedE2tInstance := e2tInstance
+       updatedE2tInstance.AssociatedRanList = []string{}
+       writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
+
+       rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
+       mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction)
+       rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 
-       nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
-       nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
-       nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_CONNECTED,}
-       readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
-       readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
-       readerMock.On("GetNodeb", "RanName_3").Return(nb3, nil)
-
-       errRnib := &common.ResourceNotFoundError{}
-       updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
-       updatedNb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
-       writerMock.On("SaveNodeb", mock.Anything, updatedNb1).Return(nil)
-       writerMock.On("SaveNodeb", mock.Anything, updatedNb3).Return(errRnib)
-
-       //after timer: ShutDown->Ignore, ShuttingDown->ShutDown(will fail)
        readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
-
-       nb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
-       nb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
-       nb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
-       readerMock.On("GetNodeb", "RanName_1").Return(nb1AfterTimer, nil)
-       readerMock.On("GetNodeb", "RanName_2").Return(nb2AfterTimer, nil)
-       readerMock.On("GetNodeb", "RanName_3").Return(nb3AfterTimer, nil)
-
-       updatedNb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
-       updatedNb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
-       writerMock.On("SaveNodeb", mock.Anything, updatedNb2AfterTimer).Return(nil)
-       writerMock.On("SaveNodeb", mock.Anything, updatedNb3AfterTimer).Return(errRnib)
-
-       mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
-       rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), true).Return(mbuf, nil)
-
-       _, actual := handler.Handle(nil)
-
-       assert.Nil(t, actual)
+       readerMock.On("GetNodeb", "RanName_1").Return(updatedNb1, nil)
+       updatedNb2 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
+       writerMock.On("UpdateNodebInfo", updatedNb2).Return(nil)
+       _, err := h.Handle(nil)
+       assert.Nil(t, err)
+       rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
+       readerMock.AssertExpectations(t)
+       writerMock.AssertExpectations(t)
+       writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
 }
 
-func TestHandleSendRmrFailedFlow(t *testing.T) {
-       log, config, readerMock, writerMock, rnibDataService, rmrMessengerMock := setupTest(t)
-
-       config.BigRedButtonTimeoutSec = 1
-       handler := NewDeleteAllRequestHandler(log, getRmrSender(rmrMessengerMock, log), config, rnibDataService)
-
-       //Before timer: Disconnected->ShutDown, ShuttingDown->Ignore, Connected->ShuttingDown(will fail)
-       nbIdentityList := createIdentityList()
+func TestSuccessTwoE2TInstancesSixRans(t *testing.T) {
+       h, readerMock, writerMock, rmrMessengerMock, httpClientMock := setupDeleteAllRequestHandlerTest(t)
+       e2tAddresses := []string{E2TAddress, E2TAddress2}
+       readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
+       mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
+       nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}, {InventoryName: "RanName_3"}, {InventoryName: "RanName_4"}, {InventoryName: "RanName_5"}, {InventoryName: "RanName_6"}}
        readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
+       //nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
+       //readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
+       //nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
+       //readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
+       //nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
+       //readerMock.On("GetNodeb", "RanName_3").Return(nb3, nil)
+       //nb4 := &entities.NodebInfo{RanName: "RanName_4", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress2}
+       //readerMock.On("GetNodeb", "RanName_4").Return(nb4, nil)
+       //nb5 := &entities.NodebInfo{RanName: "RanName_5", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress2}
+       //readerMock.On("GetNodeb", "RanName_5").Return(nb5, nil)
+       //nb6 := &entities.NodebInfo{RanName: "RanName_6", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress2}
+       //readerMock.On("GetNodeb", "RanName_6").Return(nb6, nil)
 
-       nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
-       nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
-       nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_CONNECTED,}
-       readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
-       readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
-       readerMock.On("GetNodeb", "RanName_3").Return(nb3, nil)
-
-       updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
+       updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
+       writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
+       updatedNb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
+       writerMock.On("UpdateNodebInfo", updatedNb2).Return(nil)
        updatedNb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
-       writerMock.On("SaveNodeb", mock.Anything, updatedNb1).Return(nil)
-       writerMock.On("SaveNodeb", mock.Anything, updatedNb3).Return(nil)
+       writerMock.On("UpdateNodebInfo", updatedNb3).Return(nil)
+       updatedNb4 := &entities.NodebInfo{RanName: "RanName_4", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
+       writerMock.On("UpdateNodebInfo", updatedNb4).Return(nil)
+       updatedNb5 := &entities.NodebInfo{RanName: "RanName_5", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
+       writerMock.On("UpdateNodebInfo", updatedNb5).Return(nil)
+       updatedNb6 := &entities.NodebInfo{RanName: "RanName_6", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
+       writerMock.On("UpdateNodebInfo", updatedNb6).Return(nil)
+
+       readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
+       e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1", "RanName_2", "RanName_3"}}
+       e2tInstance2 := entities.E2TInstance{Address: E2TAddress2, AssociatedRanList: []string{"RanName_4", "RanName_5", "RanName_6"}}
+       readerMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{&e2tInstance, &e2tInstance2}, nil)
+       updatedE2tInstance := e2tInstance
+       updatedE2tInstance.AssociatedRanList = []string{}
+       updatedE2tInstance2 := e2tInstance2
+       updatedE2tInstance2.AssociatedRanList = []string{}
+       writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
+       writerMock.On("SaveE2TInstance", &updatedE2tInstance2).Return(nil)
+
+       rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
+       mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction)
+       rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 
-       //after timer: ShutDown->Ignore, ShuttingDown->ShutDown(will fail)
        readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
-
-       nb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
-       nb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
-       nb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
-       readerMock.On("GetNodeb", "RanName_1").Return(nb1AfterTimer, nil)
-       readerMock.On("GetNodeb", "RanName_2").Return(nb2AfterTimer, nil)
-       readerMock.On("GetNodeb", "RanName_3").Return(nb3AfterTimer, nil)
-
-       updatedNb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
-       updatedNb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
-       writerMock.On("SaveNodeb", mock.Anything, updatedNb2AfterTimer).Return(nil)
-       writerMock.On("SaveNodeb", mock.Anything, updatedNb3AfterTimer).Return(nil)
-
-       expected := e2managererrors.NewRmrError()
-       mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
-       rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), true).Return(mbuf, expected)
-
-       _, actual := handler.Handle(nil)
-
-       if reflect.TypeOf(actual) != reflect.TypeOf(expected) {
-               t.Errorf("Error actual = %v, and Expected = %v.", actual, expected)
-       }
-}
-
-func TestHandleGetListEnbIdsEmptyFlow(t *testing.T) {
-       log, config, readerMock, _, rnibDataService, rmrMessengerMock := setupTest(t)
-
-       handler := NewDeleteAllRequestHandler(log, getRmrSender(rmrMessengerMock, log), config, rnibDataService)
-
-       var rnibError error
-       nbIdentityList := []*entities.NbIdentity{}
-
-       readerMock.On("GetListNodebIds").Return(nbIdentityList, rnibError)
-
-       _, actual := handler.Handle(nil)
-       readerMock.AssertNumberOfCalls(t, "GetNodeb", 0)
-       assert.Nil(t, actual)
-}
-
-func createIdentityList() []*entities.NbIdentity {
-       nbIdentity1 := entities.NbIdentity{InventoryName: "RanName_1"}
-       nbIdentity2 := entities.NbIdentity{InventoryName: "RanName_2"}
-       nbIdentity3 := entities.NbIdentity{InventoryName: "RanName_3"}
-
-       var nbIdentityList []*entities.NbIdentity
-       nbIdentityList = append(nbIdentityList, &nbIdentity1)
-       nbIdentityList = append(nbIdentityList, &nbIdentity2)
-       nbIdentityList = append(nbIdentityList, &nbIdentity3)
-
-       return nbIdentityList
+       readerMock.On("GetNodeb", "RanName_1").Return(updatedNb1, nil)
+       readerMock.On("GetNodeb", "RanName_2").Return(updatedNb2, nil)
+       readerMock.On("GetNodeb", "RanName_3").Return(updatedNb3, nil)
+       readerMock.On("GetNodeb", "RanName_4").Return(updatedNb4, nil)
+       readerMock.On("GetNodeb", "RanName_5").Return(updatedNb5, nil)
+       readerMock.On("GetNodeb", "RanName_6").Return(updatedNb6, nil)
+
+       updatedNb1AfterTimer := *updatedNb1
+       updatedNb1AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
+       writerMock.On("UpdateNodebInfo", &updatedNb1AfterTimer).Return(nil)
+       updatedNb2AfterTimer := *updatedNb2
+       updatedNb2AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
+       writerMock.On("UpdateNodebInfo", &updatedNb2AfterTimer).Return(nil)
+       updatedNb3AfterTimer := *updatedNb3
+       updatedNb3AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
+       writerMock.On("UpdateNodebInfo", &updatedNb3AfterTimer).Return(nil)
+       updatedNb4AfterTimer := *updatedNb4
+       updatedNb4AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
+       writerMock.On("UpdateNodebInfo", &updatedNb4AfterTimer).Return(nil)
+       updatedNb5AfterTimer := *updatedNb5
+       updatedNb5AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
+       writerMock.On("UpdateNodebInfo", &updatedNb5AfterTimer).Return(nil)
+       updatedNb6AfterTimer := *updatedNb6
+       updatedNb6AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
+       writerMock.On("UpdateNodebInfo", &updatedNb6AfterTimer).Return(nil)
+       _, err := h.Handle(nil)
+       assert.Nil(t, err)
+       rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
+       readerMock.AssertExpectations(t)
+       writerMock.AssertExpectations(t)
+       writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 12)
 }
 
 func initLog(t *testing.T) *logger.Logger {
-       log, err := logger.InitLogger(logger.InfoLevel)
+       log, err := logger.InitLogger(logger.DebugLevel)
        if err != nil {
                t.Errorf("#initLog test - failed to initialize logger, error: %s", err)
        }

diff --git a/E2Manager/managers/e2t_association_manager.go b/E2Manager/managers/e2t_association_manager.go
index b18647b..9b0cada 100644 (file)
--- a/E2Manager/managers/e2t_association_manager.go
+++ b/E2Manager/managers/e2t_association_manager.go
@@ -55,8 +55,6 @@ func (m *E2TAssociationManager) AssociateRan(e2tAddress string, nodebInfo *entit
        nodebInfo.AssociatedE2TInstanceAddress = e2tAddress
        nodebInfo.ConnectionAttempts = 0
 
-
-       m.logger.Infof("test test test test")
        rnibErr := m.rnibDataService.UpdateNodebInfo(nodebInfo)
        if rnibErr != nil {
                m.logger.Errorf("#E2TAssociationManager.AssociateRan - RAN name: %s - Failed to update RAN.AssociatedE2TInstanceAddress in rNib. Error: %s", ranName, rnibErr)

diff --git a/E2Manager/managers/e2t_instances_manager.go b/E2Manager/managers/e2t_instances_manager.go
index 0a95f5f..c970c76 100644 (file)
--- a/E2Manager/managers/e2t_instances_manager.go
+++ b/E2Manager/managers/e2t_instances_manager.go
@@ -38,6 +38,7 @@ type E2TInstancesManager struct {
 }
 
 type IE2TInstancesManager interface {
+       GetE2TAddresses() ([]string, error)
        GetE2TInstance(e2tAddress string) (*entities.E2TInstance, error)
        GetE2TInstances() ([]*entities.E2TInstance, error)
        GetE2TInstancesNoLogs() ([]*entities.E2TInstance, error)
@@ -48,6 +49,7 @@ type IE2TInstancesManager interface {
        RemoveRanFromInstance(ranName string, e2tAddress string) error
        ActivateE2TInstance(e2tInstance *entities.E2TInstance) error
        ResetKeepAliveTimestamp(e2tAddress string) error
+       ClearRansOfAllE2TInstances() error
 }
 
 func NewE2TInstancesManager(rnibDataService services.RNibDataService, logger *logger.Logger) *E2TInstancesManager {
@@ -106,7 +108,7 @@ func (m *E2TInstancesManager) GetE2TInstancesNoLogs() ([]*entities.E2TInstance,
        return e2tInstances, nil
 }
 
-func (m *E2TInstancesManager) GetE2TInstances() ([]*entities.E2TInstance, error) {
+func (m *E2TInstancesManager) GetE2TAddresses() ([]string, error) {
        e2tAddresses, err := m.rnibDataService.GetE2TAddresses()
 
        if err != nil {
@@ -114,12 +116,20 @@ func (m *E2TInstancesManager) GetE2TInstances() ([]*entities.E2TInstance, error)
                _, ok := err.(*common.ResourceNotFoundError)
 
                if !ok {
-                       m.logger.Errorf("#E2TInstancesManager.GetE2TInstances - Failed retrieving E2T addresses. error: %s", err)
+                       m.logger.Errorf("#E2TInstancesManager.GetE2TAddresses - Failed retrieving E2T addresses. error: %s", err)
                        return nil, e2managererrors.NewRnibDbError()
                }
 
-               m.logger.Infof("#E2TInstancesManager.GetE2TInstances - Empty E2T addresses list")
-               return []*entities.E2TInstance{}, nil
+       }
+
+       return e2tAddresses, nil
+}
+
+func (m *E2TInstancesManager) GetE2TInstances() ([]*entities.E2TInstance, error) {
+       e2tAddresses, err := m.GetE2TAddresses()
+
+       if err != nil {
+               return nil, e2managererrors.NewRnibDbError()
        }
 
        if len(e2tAddresses) == 0 {
@@ -312,7 +322,7 @@ func (m *E2TInstancesManager) AddRanToInstance(ranName string, e2tAddress string
        return nil
 }
 
-func (m E2TInstancesManager) ActivateE2TInstance(e2tInstance *entities.E2TInstance) error{
+func (m E2TInstancesManager) ActivateE2TInstance(e2tInstance *entities.E2TInstance) error {
 
        if e2tInstance == nil {
                m.logger.Errorf("#E2TInstancesManager.ActivateE2TInstance - e2tInstance empty")
@@ -360,3 +370,31 @@ func (m *E2TInstancesManager) ResetKeepAliveTimestamp(e2tAddress string) error {
 
        return nil
 }
+
+func (m *E2TInstancesManager) ClearRansOfAllE2TInstances() error {
+
+       m.mux.Lock()
+       defer m.mux.Unlock()
+
+       e2tInstances, err := m.GetE2TInstances()
+
+       if err != nil {
+               return err
+       }
+
+       if len(e2tInstances) == 0 {
+               m.logger.Errorf("#E2TInstancesManager.ClearRansOfAllE2TInstances - No E2T instances to clear associated RANs from")
+               return nil
+       }
+
+       for _, v := range e2tInstances {
+               v.AssociatedRanList = []string{}
+               err := m.rnibDataService.SaveE2TInstance(v)
+
+               if err != nil {
+                       m.logger.Errorf("#E2TInstancesManager.ClearRansOfAllE2TInstances - e2t address: %s - failed saving e2t instance. error: %s", v.Address, err)
+               }
+       }
+
+       return nil
+}

diff --git a/E2Manager/mocks/e2t_instances_manager_mock.go b/E2Manager/mocks/e2t_instances_manager_mock.go
index 586f396..5919f9c 100644 (file)
--- a/E2Manager/mocks/e2t_instances_manager_mock.go
+++ b/E2Manager/mocks/e2t_instances_manager_mock.go
@@ -82,5 +82,14 @@ func (m *E2TInstancesManagerMock) ResetKeepAliveTimestamp(e2tAddress string) err
 func (m *E2TInstancesManagerMock) ActivateE2TInstance(e2tInstance *entities.E2TInstance) error {
        args := m.Called(e2tInstance)
        return args.Error(0)
+}
+
+func (m *E2TInstancesManagerMock) GetE2TAddresses() ([]string, error) {
+       args := m.Called()
+       return args.Get(0).([]string), args.Error(1)
+}
 
-}
\ No newline at end of file
+func (m *E2TInstancesManagerMock) ClearRansOfAllE2TInstances() error {
+       args := m.Called()
+       return args.Error(0)
+}

diff --git a/E2Manager/mocks/routing_manager_client_mock.go b/E2Manager/mocks/routing_manager_client_mock.go
index 24edd55..fb1cafd 100644 (file)
--- a/E2Manager/mocks/routing_manager_client_mock.go
+++ b/E2Manager/mocks/routing_manager_client_mock.go
@@ -43,4 +43,10 @@ func (m *RoutingManagerClientMock) DissociateRanE2TInstance(e2tAddress string, r
 
        args := m.Called(e2tAddress, ranName)
        return args.Error(0)
+}
+
+func (m *RoutingManagerClientMock) DissociateAllRans(e2tAddresses []string) error {
+
+args := m.Called(e2tAddresses)
+return args.Error(0)
 }
\ No newline at end of file

diff --git a/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider.go b/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider.go
index 6a306e1..cfbda44 100644 (file)
--- a/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider.go
+++ b/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider.go
@@ -20,6 +20,7 @@
 package httpmsghandlerprovider
 
 import (
+       "e2mgr/clients"
        "e2mgr/configuration"
        "e2mgr/e2managererrors"
        "e2mgr/handlers/httpmsghandlers"
@@ -47,18 +48,18 @@ type IncomingRequestHandlerProvider struct {
        logger     *logger.Logger
 }
 
-func NewIncomingRequestHandlerProvider(logger *logger.Logger, rmrSender *rmrsender.RmrSender, config *configuration.Configuration, rNibDataService services.RNibDataService, ranSetupManager *managers.RanSetupManager, e2tInstancesManager managers.IE2TInstancesManager, e2tAssociationManager *managers.E2TAssociationManager) *IncomingRequestHandlerProvider {
+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),
+               requestMap: initRequestHandlerMap(logger, rmrSender, config, rNibDataService, ranSetupManager, e2tInstancesManager, e2tAssociationManager, 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) map[IncomingRequest]httpmsghandlers.RequestHandler {
+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 {
 
        return map[IncomingRequest]httpmsghandlers.RequestHandler{
-               ShutdownRequest:  httpmsghandlers.NewDeleteAllRequestHandler(logger, rmrSender, config, rNibDataService), //TODO change to pointer
+               ShutdownRequest:  httpmsghandlers.NewDeleteAllRequestHandler(logger, rmrSender, config, rNibDataService, e2tInstancesManager, rmClient),
                ResetRequest:     httpmsghandlers.NewX2ResetRequestHandler(logger, rmrSender, rNibDataService),
                X2SetupRequest:   httpmsghandlers.NewSetupRequestHandler(logger, rNibDataService, ranSetupManager, entities.E2ApplicationProtocol_X2_SETUP_REQUEST, e2tInstancesManager, e2tAssociationManager),
                EndcSetupRequest: httpmsghandlers.NewSetupRequestHandler(logger, rNibDataService, ranSetupManager, entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, e2tInstancesManager, e2tAssociationManager),

diff --git a/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider_test.go b/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider_test.go
index 2d223b8..e06105f 100644 (file)
--- a/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider_test.go
+++ b/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider_test.go
@@ -57,7 +57,7 @@ func setupTest(t *testing.T) *IncomingRequestHandlerProvider {
        httpClientMock := &mocks.HttpClientMock{}
        rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
        e2tAssociationManager := managers.NewE2TAssociationManager(log, rnibDataService, e2tInstancesManager, rmClient)
-       return NewIncomingRequestHandlerProvider(log, rmrSender, configuration.ParseConfiguration(), rnibDataService, ranSetupManager, e2tInstancesManager, e2tAssociationManager)
+       return NewIncomingRequestHandlerProvider(log, rmrSender, configuration.ParseConfiguration(), rnibDataService, ranSetupManager, e2tInstancesManager, e2tAssociationManager, rmClient)
 }
 
 func TestNewIncomingRequestHandlerProvider(t *testing.T) {

diff --git a/E2Manager/stateMachine/delete_all_node_state_machine.go b/E2Manager/stateMachine/delete_all_node_state_machine.go
deleted file mode 100644 (file)
index eafd6c6..0000000
--- a/E2Manager/stateMachine/delete_all_node_state_machine.go
+++ /dev/null
@@ -1,43 +0,0 @@
-//
-// 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.
-
-//  This source code is part of the near-RT RIC (RAN Intelligent Controller)
-//  platform project (RICP).
-
-
-package stateMachine
-
-import (
-       "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
-)
-
-
-var nodeStateMap = map[entities.ConnectionStatus]entities.ConnectionStatus{
-       entities.ConnectionStatus_CONNECTING:   entities.ConnectionStatus_SHUTTING_DOWN,
-       entities.ConnectionStatus_CONNECTED:    entities.ConnectionStatus_SHUTTING_DOWN,
-       entities.ConnectionStatus_CONNECTED_SETUP_FAILED:       entities.ConnectionStatus_SHUTTING_DOWN,
-       entities.ConnectionStatus_DISCONNECTED: entities.ConnectionStatus_SHUT_DOWN,
-}
-
-func NodeNextStateDeleteAll(state entities.ConnectionStatus) (entities.ConnectionStatus, bool) {
-       nextState, error := nodeStateMap[state]
-
-       if !error {
-               return state, false
-       }
-
-       return nextState, true
-}

diff --git a/E2Manager/stateMachine/delete_all_node_state_machine_test.go b/E2Manager/stateMachine/delete_all_node_state_machine_test.go
deleted file mode 100644 (file)
index 035bd35..0000000
--- a/E2Manager/stateMachine/delete_all_node_state_machine_test.go
+++ /dev/null
@@ -1,33 +0,0 @@
-//
-// 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.
-
-//  This source code is part of the near-RT RIC (RAN Intelligent Controller)
-//  platform project (RICP).
-
-package stateMachine
-
-import (
-       "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
-       "github.com/stretchr/testify/assert"
-       "testing"
-)
-
-func TestNodeNextStateDeleteAll(t *testing.T) {
-
-       _, result := NodeNextStateDeleteAll(entities.ConnectionStatus_UNKNOWN_CONNECTION_STATUS)
-
-       assert.False(t, result)
-}