e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, logger)
routingManagerClient := clients.NewRoutingManagerClient(logger, config, clients.NewHttpClient())
e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManager, routingManagerClient)
- e2tShutdownManager := managers.NewE2TShutdownManager(logger, config, rnibDataService, e2tInstancesManager, e2tAssociationManager, ranSetupManager)
+ e2tShutdownManager := managers.NewE2TShutdownManager(logger, config, rnibDataService, e2tInstancesManager, e2tAssociationManager)
e2tKeepAliveWorker := managers.NewE2TKeepAliveWorker(logger, rmrSender, e2tInstancesManager, e2tShutdownManager, config)
rmrNotificationHandlerProvider := rmrmsghandlerprovider.NewNotificationHandlerProvider()
rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient, e2tAssociationManager)
AssociateRanToE2TInstance(e2tAddress string, ranName string) error
DissociateRanE2TInstance(e2tAddress string, ranName string) error
DissociateAllRans(e2tAddresses []string) error
- DeleteE2TInstance(e2tAddress string, ransToBeDissociated []string, e2tToRansAssociations map[string][]string) error
+ DeleteE2TInstance(e2tAddress string, ransToBeDissociated []string) error
}
func NewRoutingManagerClient(logger *logger.Logger, config *configuration.Configuration, httpClient IHttpClient) *RoutingManagerClient {
return c.PostMessage(url, data)
}
-func (c *RoutingManagerClient) DeleteE2TInstance(e2tAddress string, ransTobeDissociated []string, e2tToRansAssociations map[string][]string) error {
- e2tDataList := convertE2TToRansAssociationsMapToE2TDataList(e2tToRansAssociations)
- data := models.NewRoutingManagerDeleteRequestModel(e2tAddress, ransTobeDissociated, e2tDataList)
+func (c *RoutingManagerClient) DeleteE2TInstance(e2tAddress string, ransTobeDissociated []string) error {
+ data := models.NewRoutingManagerDeleteRequestModel(e2tAddress, ransTobeDissociated, nil)
url := c.config.RoutingManager.BaseUrl + DeleteE2TInstanceApiSuffix
return c.DeleteMessage(url, data)
}
func TestDeleteE2TInstanceSuccess(t *testing.T) {
rmClient, httpClientMock, config := initRoutingManagerClientTest(t)
- e2tToRansAssociations := map[string][]string{
- E2TAddress2: {"test1"},
- }
- e2tDataList := convertE2TToRansAssociationsMapToE2TDataList(e2tToRansAssociations)
- data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1"},e2tDataList)
+ data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1"}, nil)
marshaled, _ := json.Marshal(data)
body := bytes.NewBuffer(marshaled)
url := config.RoutingManager.BaseUrl + "e2t"
respBody := ioutil.NopCloser(bytes.NewBufferString(""))
httpClientMock.On("Delete", url, "application/json", body).Return(&http.Response{StatusCode: http.StatusOK, Body: respBody}, nil)
- err := rmClient.DeleteE2TInstance(E2TAddress, []string{"test1"}, e2tToRansAssociations)
+ err := rmClient.DeleteE2TInstance(E2TAddress, []string{"test1"})
assert.Nil(t, err)
}
func TestDeleteE2TInstanceFailure(t *testing.T) {
rmClient, httpClientMock, config := initRoutingManagerClientTest(t)
- e2tToRansAssociations := map[string][]string{
- E2TAddress2: {"test1"},
- }
- e2tDataList := convertE2TToRansAssociationsMapToE2TDataList(e2tToRansAssociations)
- data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1"},e2tDataList)
+ data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1"},nil)
marshaled, _ := json.Marshal(data)
body := bytes.NewBuffer(marshaled)
url := config.RoutingManager.BaseUrl + "e2t"
respBody := ioutil.NopCloser(bytes.NewBufferString(""))
httpClientMock.On("Delete", url, "application/json", body).Return(&http.Response{StatusCode: http.StatusBadRequest, Body: respBody}, nil)
- err := rmClient.DeleteE2TInstance(E2TAddress, []string{"test1"}, e2tToRansAssociations)
+ err := rmClient.DeleteE2TInstance(E2TAddress, []string{"test1"})
assert.IsType(t, &e2managererrors.RoutingManagerError{}, err)
}
func TestDeleteE2TInstanceDeleteFailure(t *testing.T) {
rmClient, httpClientMock, config := initRoutingManagerClientTest(t)
- e2tToRansAssociations := map[string][]string{
- E2TAddress2: {"test1"},
- }
- e2tDataList := convertE2TToRansAssociationsMapToE2TDataList(e2tToRansAssociations)
- data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1"},e2tDataList)
+ data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1"},nil)
marshaled, _ := json.Marshal(data)
body := bytes.NewBuffer(marshaled)
url := config.RoutingManager.BaseUrl + "e2t"
httpClientMock.On("Delete", url, "application/json", body).Return(&http.Response{}, errors.New("error"))
- err := rmClient.DeleteE2TInstance(E2TAddress, []string{"test1"}, e2tToRansAssociations)
+ err := rmClient.DeleteE2TInstance(E2TAddress, []string{"test1"})
assert.IsType(t, &e2managererrors.RoutingManagerError{}, err)
}
module e2mgr
require (
- gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common v1.0.29
- gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities v1.0.29
- gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader v1.0.29
+ gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common v1.0.30
+ gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities v1.0.30
+ gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader v1.0.30
gerrit.o-ran-sc.org/r/ric-plt/sdlgo v0.5.2
github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a // indirect
github.com/go-ozzo/ozzo-validation v3.5.0+incompatible
cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common v1.0.29 h1:T0ydbEy2pmP2n8A/eyx5iF5PNm0XYa3A5G5HmXsN0Wo=
-gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common v1.0.29/go.mod h1:QJ1uPPZosGbhxUWpUpeM5fLqFHdnWTrVnvW2DgyOCes=
-gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities v1.0.29 h1:H/6CeGFUwS4S1DJ2OVwjt/qKmm/VTdgcgHcxBJfrQt4=
-gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities v1.0.29/go.mod h1:Fh23KkroYw5CRBh39WzZzxpKSkpQWL3scdzGnMngLo8=
-gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader v1.0.29 h1:eke+zU8y2gQmEBxAQryBXwBWwvXSHeu+pC11t8luQBQ=
-gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader v1.0.29/go.mod h1:EPOJ7YGXDS5F+IK1pa9cv2JYlj73PYOXVvgolhhCSfM=
+gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common v1.0.30 h1:GuA/5jPx+Srjcs38Bja0392Ht+7ubUOyBbCAp4QRCJY=
+gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common v1.0.30/go.mod h1:QJ1uPPZosGbhxUWpUpeM5fLqFHdnWTrVnvW2DgyOCes=
+gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities v1.0.30 h1:MBOyQeDNA+8rs8OSsEIuh7oHhO/5v7ISimd/BMRhLYA=
+gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities v1.0.30/go.mod h1:Fh23KkroYw5CRBh39WzZzxpKSkpQWL3scdzGnMngLo8=
+gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader v1.0.30 h1:fL5qY6KS5RRxvduCnXeK8fWj7YUF1p9b9ObduFSSlRs=
+gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader v1.0.30/go.mod h1:HeUXZTDqAaGYiVVcWrHwgY0qDNQ6Rt6nZSvWdMueDNc=
gerrit.o-ran-sc.org/r/ric-plt/sdlgo.git v0.5.2 h1:UK7awyRKIkVdokWvvkYvazlg3EWIfMnIqCcJxTnLlDA=
gerrit.o-ran-sc.org/r/ric-plt/sdlgo.git v0.5.2/go.mod h1:y2WhrCvdLkAKdH+ySdHSOSehACJkTMyZghCGVcqoZzc=
github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
return
}
- if e2tInstance.State == entities.RoutingManagerFailure {
- err := h.e2tInstancesManager.SetE2tInstanceState(e2tAddress, e2tInstance.State, entities.Active)
- if err != nil {
- return
- }
- }
-
h.HandleExistingE2TInstance(e2tInstance)
h.logger.Infof("#E2TermInitNotificationHandler.Handle - Completed handling of E2_TERM_INIT")
"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"
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)
-
- httpClientMock.AssertCalled(t, "Post", url, mock.Anything, mock.Anything)
- writerMock.AssertNotCalled(t, "SaveE2TInstance", mock.Anything)
- writerMock.AssertNotCalled(t, "SaveE2TAddresses", mock.Anything)
-}
-
func TestE2TermInitExistingE2TInstanceNoAssociatedRans(t *testing.T) {
_, handler, _, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
rmrMessengerMock.AssertNotCalled(t, "SendMsg")
}
-//func TestE2TermInitHandlerSuccessTwoRans_RoutingManagerFailure(t *testing.T) {
-// _, _, handler, readerMock, writerMock, rmrMessengerMock, httpClientMock:= initRanLostConnectionTestWithRealE2tInstanceManager(t)
-//
-// var rnibErr error
-// var initialNodeb0 = &entities.NodebInfo{RanName: RanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
-// var initialNodeb1 = &entities.NodebInfo{RanName: "test2", ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
-// readerMock.On("GetNodeb", RanName).Return(initialNodeb0, rnibErr)
-// readerMock.On("GetNodeb", "test2").Return(initialNodeb1, rnibErr)
-// writerMock.On("UpdateNodebInfo", mock.Anything).Return(rnibErr)
-//
-// payload := e2pdus.PackedX2setupRequest
-// xaction := []byte(RanName)
-// msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), RanName, &payload, &xaction)
-//
-// rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
-//
-// e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
-// e2tInstance.State = entities.RoutingManagerFailure
-// e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName, "test2")
-//
-// readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
-// writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
-//
-// notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
-//
-// handler.Handle(notificationRequest)
-//
-// rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 2)
-// writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
-//
-// httpClientMock.AssertNotCalled(t, "Post", mock.Anything, mock.Anything, mock.Anything)
-// writerMock.AssertCalled(t, "SaveE2TInstance", mock.Anything)
-//}
-
-func TestE2TermInitHandlerSuccessOneRan_RoutingManagerFailure_Error(t *testing.T) {
- _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(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, ConnectionAttempts: 1}
- writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
-
- payload := e2pdus.PackedX2setupRequest
- xaction := []byte(RanName)
- msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), RanName, &payload, &xaction)
-
- rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
-
- e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
- e2tInstance.State = entities.RoutingManagerFailure
- e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
-
- e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
- e2tInstancesManagerMock.On("SetE2tInstanceState", e2tInstanceAddress, e2tInstance.State, entities.Active).Return(fmt.Errorf(" Error "))
- writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
-
- notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
-
- handler.Handle(notificationRequest)
-
- writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 0)
- rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 0)
-}
-
//func TestE2TermInitHandlerSuccessTwoRans(t *testing.T) {
// _, _, handler, readerMock, writerMock, rmrMessengerMock, httpClientMock:= initRanLostConnectionTestWithRealE2tInstanceManager(t)
// var rnibErr error
return nil
}
-func (m *E2TAssociationManager) RemoveE2tInstance(e2tInstance *entities.E2TInstance, ransToBeDissociated []string, ranAssociationList map[string][]string) error {
- m.logger.Infof("#E2TAssociationManager.RemoveE2tInstance - Removing E2T %s and re-associating its associated RANs.", e2tInstance.Address)
+func (m *E2TAssociationManager) RemoveE2tInstance(e2tInstance *entities.E2TInstance) error {
+ m.logger.Infof("#E2TAssociationManager.RemoveE2tInstance - Removing E2T %s and dessociating its associated RANs.", e2tInstance.Address)
- err := m.rmClient.DeleteE2TInstance(e2tInstance.Address, ransToBeDissociated, ranAssociationList)
+ err := m.rmClient.DeleteE2TInstance(e2tInstance.Address, e2tInstance.AssociatedRanList)
if err != nil {
- _ = m.setStateToRoutingManagerFailure(e2tInstance)
- m.logger.Errorf("#E2TAssociationManager.RemoveE2tInstance - RoutingManager failure: Failed to delete E2T %s. Error: %s", e2tInstance.Address, err)
- return err
+ m.logger.Warnf("#E2TAssociationManager.RemoveE2tInstance - RoutingManager failure: Failed to delete E2T %s. Error: %s", e2tInstance.Address, err)
+ // log and continue
}
err = m.e2tInstanceManager.RemoveE2TInstance(e2tInstance.Address)
return err
}
- for e2tAddress, associatedRans := range ranAssociationList {
- err = m.e2tInstanceManager.AddRansToInstance(e2tAddress, associatedRans)
- if err != nil {
- m.logger.Errorf("#E2TAssociationManager.RemoveE2tInstance - Failed to add RANs %s to E2T %s. Error: %s", associatedRans, e2tAddress, err)
- return err
- }
- }
-
m.logger.Infof("#E2TAssociationManager.RemoveE2tInstance - E2T %s successfully removed.", e2tInstance.Address)
return nil
}
-
-func (m *E2TAssociationManager) setStateToRoutingManagerFailure(e2tInstance *entities.E2TInstance) error {
-
- err := m.e2tInstanceManager.SetE2tInstanceState(e2tInstance.Address, e2tInstance.State, entities.RoutingManagerFailure)
- if err != nil {
- return err
- }
- return nil
-}
"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"
"io/ioutil"
"net/http"
"testing"
httpClientMock.AssertExpectations(t)
}
-func TestRemoveE2tInstanceSuccess(t *testing.T) {
- manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
-
- e2tDataList := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress2, RanName), models.NewRoutingManagerE2TData(E2TAddress3, "test1")}
- data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, nil, e2tDataList)
- mockHttpClientDelete(httpClientMock, data, true)
-
- writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
- e2tAddresses := []string{E2TAddress, E2TAddress2, E2TAddress3}
- readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
- e2tAddressesNew := []string{E2TAddress2, E2TAddress3}
- writerMock.On("SaveE2TAddresses", e2tAddressesNew).Return(nil)
-
- e2tInstance1 := &entities.E2TInstance{Address: E2TAddress}
- e2tInstance2 := &entities.E2TInstance{Address: E2TAddress2}
- readerMock.On("GetE2TInstance", E2TAddress2).Return(e2tInstance2, nil)
- e2tInstance3 := &entities.E2TInstance{Address: E2TAddress3}
- readerMock.On("GetE2TInstance", E2TAddress3).Return(e2tInstance3, nil)
-
- e2tInstance2updated := *e2tInstance2
- e2tInstance2updated.AssociatedRanList = []string{RanName}
- writerMock.On("SaveE2TInstance", &e2tInstance2updated).Return(nil)
- e2tInstance3updated := *e2tInstance3
- e2tInstance3updated.AssociatedRanList = []string{"test1"}
- writerMock.On("SaveE2TInstance", &e2tInstance3updated).Return(nil)
-
- ranNamesToBeAssociated := make(map[string][]string)
- ranNamesToBeAssociated[E2TAddress2] = []string{RanName}
- ranNamesToBeAssociated[E2TAddress3] = []string{"test1"}
- err := manager.RemoveE2tInstance(e2tInstance1, nil, ranNamesToBeAssociated)
-
- assert.Nil(t, err)
- readerMock.AssertExpectations(t)
- writerMock.AssertExpectations(t)
- httpClientMock.AssertExpectations(t)
-}
-
func TestRemoveE2tInstanceSuccessWithOrphans(t *testing.T) {
manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
e2tAddressesNew := []string{}
writerMock.On("SaveE2TAddresses", e2tAddressesNew).Return(nil)
- e2tInstance1 := &entities.E2TInstance{Address: E2TAddress}
- err := manager.RemoveE2tInstance(e2tInstance1, ranNamesToBeDissociated, nil)
+ e2tInstance1 := &entities.E2TInstance{Address: E2TAddress, AssociatedRanList:ranNamesToBeDissociated}
+ err := manager.RemoveE2tInstance(e2tInstance1)
assert.Nil(t, err)
readerMock.AssertExpectations(t)
func TestRemoveE2tInstanceFailureRoutingManager(t *testing.T) {
manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
- e2tDataList := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress, RanName)}
- data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1"}, e2tDataList)
+ data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1"}, nil)
mockHttpClientDelete(httpClientMock, data, false)
- e2tInstance1 := entities.NewE2TInstance(E2TAddress)
- e2tInstance1.State = entities.Active
- readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, nil)
- e2tInstance2 := *e2tInstance1
- e2tInstance2.State = entities.RoutingManagerFailure
- writerMock.On("SaveE2TInstance", &e2tInstance2).Return(nil)
- ranNamesToBeAssociated := make(map[string][]string)
- ranNamesToBeAssociated[E2TAddress] = []string{"test"}
- err := manager.RemoveE2tInstance(e2tInstance1, []string{"test1"}, ranNamesToBeAssociated)
-
- assert.NotNil(t, err)
- readerMock.AssertExpectations(t)
- writerMock.AssertExpectations(t)
- httpClientMock.AssertExpectations(t)
-}
-
-func TestRemoveE2tInstanceFailureRoutingManagerAndGetInstance(t *testing.T) {
- manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
-
- e2tDataList := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress, RanName)}
- data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1"}, e2tDataList)
- mockHttpClientDelete(httpClientMock, data, false)
-
- e2tInstance1 := &entities.E2TInstance{Address: E2TAddress}
- readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, e2managererrors.NewRnibDbError())
- ranNamesToBeAssociated := make(map[string][]string)
- ranNamesToBeAssociated[E2TAddress] = []string{"test"}
- err := manager.RemoveE2tInstance(e2tInstance1, []string{"test1"}, ranNamesToBeAssociated)
-
- assert.NotNil(t, err)
- readerMock.AssertExpectations(t)
- writerMock.AssertExpectations(t)
- httpClientMock.AssertExpectations(t)
-}
-
-func TestRemoveE2tInstanceFailureRoutingManagerAndSetInstanceState(t *testing.T) {
- manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
-
- e2tDataList := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress, RanName)}
- data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1"}, e2tDataList)
- mockHttpClientDelete(httpClientMock, data, false)
+ writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
+ e2tAddresses := []string{E2TAddress}
+ readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
+ e2tAddressesNew := []string{}
+ writerMock.On("SaveE2TAddresses", e2tAddressesNew).Return(nil)
- e2tInstance1 := entities.NewE2TInstance(E2TAddress)
- e2tInstance1.State = entities.Active
- readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, nil)
- e2tInstance2 := *e2tInstance1
- e2tInstance2.State = entities.RoutingManagerFailure
- writerMock.On("SaveE2TInstance", &e2tInstance2).Return(e2managererrors.NewRnibDbError())
- ranNamesToBeAssociated := make(map[string][]string)
- ranNamesToBeAssociated[E2TAddress] = []string{"test"}
- err := manager.RemoveE2tInstance(e2tInstance1, []string{"test1"}, ranNamesToBeAssociated)
+ e2tInstance1 := &entities.E2TInstance{Address: E2TAddress, AssociatedRanList:[]string{"test1"}}
+ //readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, e2managererrors.NewRnibDbError())
+ err := manager.RemoveE2tInstance(e2tInstance1)
- assert.NotNil(t, err)
+ assert.Nil(t, err)
readerMock.AssertExpectations(t)
writerMock.AssertExpectations(t)
httpClientMock.AssertExpectations(t)
func TestRemoveE2tInstanceFailureInE2TInstanceManager(t *testing.T) {
- e2tDataList := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress, RanName)}
- data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1"}, e2tDataList)
+ data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1"}, nil)
manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
mockHttpClientDelete(httpClientMock, data, true)
var e2tAddresses []string
readerMock.On("GetE2TAddresses").Return(e2tAddresses, e2managererrors.NewRnibDbError())
- ranNamesToBeAssociated := make(map[string][]string)
- ranNamesToBeAssociated[E2TAddress] = []string{"test"}
- e2tInstance1 := &entities.E2TInstance{Address: E2TAddress}
- err := manager.RemoveE2tInstance(e2tInstance1, []string{"test1"}, ranNamesToBeAssociated)
+ e2tInstance1 := &entities.E2TInstance{Address: E2TAddress, AssociatedRanList:[]string{"test1"}}
+ err := manager.RemoveE2tInstance(e2tInstance1)
assert.NotNil(t, err)
readerMock.AssertExpectations(t)
func TestRemoveE2tInstanceFailureInE2tInstanceAddRansToInstance(t *testing.T) {
manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
- e2tDataList := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress2, RanName), models.NewRoutingManagerE2TData(E2TAddress3, "test1")}
- data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, nil, e2tDataList)
+ data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, nil, nil)
mockHttpClientDelete(httpClientMock, data, true)
writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
e2tAddressesNew := []string{E2TAddress2, E2TAddress3}
writerMock.On("SaveE2TAddresses", e2tAddressesNew).Return(nil)
- var e2tInstance2 *entities.E2TInstance
- readerMock.On("GetE2TInstance", mock.Anything).Return(e2tInstance2, e2managererrors.NewRnibDbError())
-
- ranNamesToBeAssociated := make(map[string][]string)
- ranNamesToBeAssociated[E2TAddress2] = []string{RanName}
- ranNamesToBeAssociated[E2TAddress3] = []string{"test1"}
-
e2tInstance1 := &entities.E2TInstance{Address: E2TAddress}
- err := manager.RemoveE2tInstance(e2tInstance1, nil, ranNamesToBeAssociated)
+ err := manager.RemoveE2tInstance(e2tInstance1)
- assert.NotNil(t, err)
+ assert.Nil(t, err)
readerMock.AssertExpectations(t)
writerMock.AssertExpectations(t)
httpClientMock.AssertExpectations(t)
return err
}
- if e2tInstance.State == entities.ToBeDeleted || e2tInstance.State == entities.RoutingManagerFailure {
+ if e2tInstance.State == entities.ToBeDeleted {
m.logger.Warnf("#E2TInstancesManager.ResetKeepAliveTimestamp - Ignore. This Instance is about to be deleted")
return nil
rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
e2tInstance1 := entities.NewE2TInstance(E2TAddress)
- e2tInstance1.State = entities.RoutingManagerFailure
+ e2tInstance1.State = entities.ToBeDeleted
e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"}
rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, nil)
rnibWriterMock.On("SaveE2TInstance", mock.MatchedBy(func(e2tInstance *entities.E2TInstance) bool { return e2tInstance.State == entities.Active })).Return(nil)
- err := e2tInstancesManager.SetE2tInstanceState(E2TAddress, entities.RoutingManagerFailure, entities.Active)
+ err := e2tInstancesManager.SetE2tInstanceState(E2TAddress, entities.ToBeDeleted, entities.Active)
assert.Nil(t, err)
assert.Equal(t, entities.Active, e2tInstance1.State)
rnibWriterMock.AssertExpectations(t)
var e2tInstance1 *entities.E2TInstance
rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, common.NewInternalError(errors.New("for test")))
- err := e2tInstancesManager.SetE2tInstanceState(E2TAddress, entities.RoutingManagerFailure, entities.Active)
+ err := e2tInstancesManager.SetE2tInstanceState(E2TAddress, entities.ToBeDeleted, entities.Active)
assert.NotNil(t, err)
rnibWriterMock.AssertExpectations(t)
}
var e2tInstance1 *entities.E2TInstance
rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, e2managererrors.NewResourceNotFoundError())
- err := e2tInstancesManager.SetE2tInstanceState(E2TAddress, entities.RoutingManagerFailure, entities.Active)
+ err := e2tInstancesManager.SetE2tInstanceState(E2TAddress, entities.ToBeDeleted, entities.Active)
assert.NotNil(t, err)
rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
}
-func TestResetKeepAliveTimestampRoutingManagerFailure(t *testing.T) {
- rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
-
- address := "10.10.2.15:9800"
- e2tInstance := entities.NewE2TInstance(address)
- e2tInstance.State = entities.RoutingManagerFailure
- rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
-
- err := e2tInstancesManager.ResetKeepAliveTimestamp(address)
- assert.Nil(t, err)
- rnibReaderMock.AssertCalled(t, "GetE2TInstance", address)
- rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
-}
-
func TestResetKeepAliveTimestampsForAllE2TInstancesGetE2TInstancesFailure(t *testing.T) {
rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
rnibReaderMock.On("GetE2TAddresses").Return([]string{}, common.NewInternalError(errors.New("Error")))
e2tInstance1 := entities.NewE2TInstance(E2TAddress)
e2tInstance1.State = entities.ToBeDeleted
e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
- e2tInstance2.State = entities.RoutingManagerFailure
+ e2tInstance2.State = entities.ToBeDeleted
rnibReaderMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
e2tInstancesManager.ResetKeepAliveTimestampsForAllE2TInstances()
rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
rnibReaderMock.AssertExpectations(t)
rnibWriterMock.AssertExpectations(t)
}
+
+func TestSetE2tInstanceStateCurrentStateHasChanged(t *testing.T) {
+ rnibReaderMock, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+ e2tInstance := entities.NewE2TInstance(E2TAddress)
+ e2tInstance.State = entities.Active
+
+ rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
+
+ err := e2tInstancesManager.SetE2tInstanceState(E2TAddress, entities.ToBeDeleted, entities.Active)
+ assert.NotNil(t, err)
+ assert.IsType(t, e2managererrors.NewInternalError(), err)
+ rnibReaderMock.AssertExpectations(t)
+}
+
+func TestSetE2tInstanceStateErrorInSaveE2TInstance(t *testing.T) {
+ rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+ e2tInstance := entities.NewE2TInstance(E2TAddress)
+ e2tInstance.State = entities.ToBeDeleted
+ rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
+ rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(fmt.Errorf("for testing")))
+
+ err := e2tInstancesManager.SetE2tInstanceState(E2TAddress, entities.ToBeDeleted, entities.Active)
+ assert.NotNil(t, err)
+ assert.IsType(t, &common.InternalError{}, err)
+ rnibReaderMock.AssertExpectations(t)
+}
+
+func TestClearRansOfAllE2TInstancesEmptyList(t *testing.T) {
+ rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+ E2TAddresses := []string{}
+ rnibReaderMock.On("GetE2TAddresses").Return(E2TAddresses, nil)
+ err := e2tInstancesManager.ClearRansOfAllE2TInstances()
+ assert.Nil(t, err)
+ rnibReaderMock.AssertExpectations(t)
+ rnibWriterMock.AssertExpectations(t)
+}
+
+func TestClearRansOfAllE2TInstancesErrorInSaveE2TInstance(t *testing.T) {
+ rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+ addresses := []string{E2TAddress, E2TAddress2}
+ e2tInstance1 := entities.NewE2TInstance(E2TAddress)
+ e2tInstance1.AssociatedRanList = []string{"test1", "test2", "test3"}
+ e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
+ e2tInstance2.AssociatedRanList = []string{"test4", "test5", "test6", "test7"}
+
+ rnibReaderMock.On("GetE2TAddresses").Return(addresses, nil)
+ rnibReaderMock.On("GetE2TInstances", addresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
+ rnibWriterMock.On("SaveE2TInstance", mock.MatchedBy(func(e2tInstance *entities.E2TInstance) bool { return e2tInstance.Address == E2TAddress})).Return(common.NewInternalError(fmt.Errorf("for testing")))
+ rnibWriterMock.On("SaveE2TInstance", mock.MatchedBy(func(e2tInstance *entities.E2TInstance) bool { return e2tInstance.Address == E2TAddress2})).Return(nil)
+ err := e2tInstancesManager.ClearRansOfAllE2TInstances()
+ assert.Nil(t, err)
+ rnibReaderMock.AssertExpectations(t)
+ rnibWriterMock.AssertExpectations(t)
+}
rnibDataService services.RNibDataService
e2TInstancesManager IE2TInstancesManager
e2tAssociationManager *E2TAssociationManager
- ranSetupManager IRanSetupManager
}
-func NewE2TShutdownManager(logger *logger.Logger, config *configuration.Configuration, rnibDataService services.RNibDataService, e2TInstancesManager IE2TInstancesManager, e2tAssociationManager *E2TAssociationManager, ranSetupManager IRanSetupManager) *E2TShutdownManager {
+func NewE2TShutdownManager(logger *logger.Logger, config *configuration.Configuration, rnibDataService services.RNibDataService, e2TInstancesManager IE2TInstancesManager, e2tAssociationManager *E2TAssociationManager) *E2TShutdownManager {
return &E2TShutdownManager{
logger: logger,
config: config,
rnibDataService: rnibDataService,
e2TInstancesManager: e2TInstancesManager,
e2tAssociationManager: e2tAssociationManager,
- ranSetupManager: ranSetupManager,
}
}
return err
}
- ranNamesToBeDissociated := []string{}
- ranNamesToBeAssociated := make(map[string][]string) // e2tAddress -> associatedRanList
-
- for _, ranName := range e2tInstance.AssociatedRanList {
- ranNamesToBeDissociated, err = m.reAssociateRanInMemory(ranName, ranNamesToBeAssociated, ranNamesToBeDissociated)
- if err != nil {
- m.logger.Errorf("#E2TShutdownManager.Shutdown - Failed to re-associate nodeb %s.", ranName)
- return err
- }
- }
-
- err = m.e2tAssociationManager.RemoveE2tInstance(e2tInstance, ranNamesToBeDissociated, ranNamesToBeAssociated)
- if err != nil {
- m.logger.Errorf("#E2TShutdownManager.Shutdown - Failed to remove E2T %s.", e2tInstance.Address)
- return err
- }
-
- err = m.clearNodebsAssociation(ranNamesToBeDissociated)
+ err = m.clearNodebsAssociation(e2tInstance.AssociatedRanList)
if err != nil {
m.logger.Errorf("#E2TShutdownManager.Shutdown - Failed to clear nodebs association to E2T %s.", e2tInstance.Address)
return err
}
- err = m.reassociateNodebs(ranNamesToBeAssociated)
+ err = m.e2tAssociationManager.RemoveE2tInstance(e2tInstance)
if err != nil {
- m.logger.Errorf("#E2TShutdownManager.Shutdown - Failed to re-associate nodebs after killing E2T %s.", e2tInstance.Address)
+ m.logger.Errorf("#E2TShutdownManager.Shutdown - Failed to remove E2T %s.", e2tInstance.Address)
return err
}
- m.logger.Infof("#E2TShutdownManager.Shutdown - E2T %s was sutdown successfully.", e2tInstance.Address)
- return nil
-}
-
-func (m E2TShutdownManager) reassociateNodebs(ranNamesToBeAssociated map[string][]string) error {
- for e2tAddress, ranNames := range ranNamesToBeAssociated {
- err := m.associateAndSetupNodebs(ranNames, e2tAddress)
- if err != nil {
- return err
- }
-
- }
+ m.logger.Infof("#E2TShutdownManager.Shutdown - E2T %s was sutdown successfully.", e2tInstance.Address)
return nil
}
func (m E2TShutdownManager) clearNodebsAssociation(ranNamesToBeDissociated []string) error {
- return m.associateAndSetupNodebs(ranNamesToBeDissociated, "")
-}
-
-func (m E2TShutdownManager) associateAndSetupNodebs(ranNamesToBeUpdated []string, e2tAddress string) error {
- isDissociatedRans := len(e2tAddress) == 0
- for _, ranName := range ranNamesToBeUpdated {
+ for _, ranName := range ranNamesToBeDissociated {
nodeb, err := m.rnibDataService.GetNodeb(ranName)
if err != nil {
m.logger.Warnf("#E2TShutdownManager.associateAndSetupNodebs - Failed to get nodeb %s from db.", ranName)
}
return err
}
- nodeb.AssociatedE2TInstanceAddress = e2tAddress
- if isDissociatedRans{
- nodeb.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
- }
+ nodeb.AssociatedE2TInstanceAddress = ""
+ nodeb.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
err = m.rnibDataService.UpdateNodebInfo(nodeb)
if err != nil {
m.logger.Errorf("#E2TShutdownManager.associateAndSetupNodebs - Failed to save nodeb %s from db.", ranName)
return err
}
-
- if !isDissociatedRans {
- err = m.ranSetupManager.ExecuteSetup(nodeb, entities.ConnectionStatus_CONNECTING)
- if err != nil {
- m.logger.Errorf("#E2TShutdownManager.associateAndSetupNodebs - Failed to execute Setup for nodeb %s.", ranName)
- continue
- }
- }
}
return nil
}
-func (m E2TShutdownManager) reAssociateRanInMemory(ranName string, ranNamesToBeAssociated map[string][]string, ranNamesToBeDissociated []string) ([]string, error) {
- nodeb, err := m.rnibDataService.GetNodeb(ranName)
- if err != nil {
-
- _, ok := err.(*common.ResourceNotFoundError)
-
- if !ok {
- m.logger.Errorf("#E2TShutdownManager.reAssociateRanInMemory - Failed to get nodeb %s from db.", ranName)
- return ranNamesToBeDissociated, err
- }
-
- m.logger.Errorf("#E2TShutdownManager.reAssociateRanInMemory - nodeb %s not found in db. Skipping it...", ranName)
- return ranNamesToBeDissociated, nil
- }
-
- if nodeb.ConnectionStatus == entities.ConnectionStatus_SHUTTING_DOWN || nodeb.ConnectionStatus == entities.ConnectionStatus_SHUT_DOWN {
- m.logger.Errorf("#E2TShutdownManager.reAssociateRanInMemory - nodeb %s status is %s. Skipping it...", ranName, nodeb.ConnectionStatus)
- return ranNamesToBeDissociated, nil
- }
-
- selectedE2tAddress, err := m.e2TInstancesManager.SelectE2TInstance()
- if err != nil {
- m.logger.Infof("#E2TShutdownManager.reAssociateRanInMemory - No selected E2T instance for nodeb %s found.", ranName)
- ranNamesToBeDissociated = append(ranNamesToBeDissociated, ranName)
- return ranNamesToBeDissociated, nil
- }
-
- ranNamesToBeAssociated[selectedE2tAddress] = append(ranNamesToBeAssociated[selectedE2tAddress], ranName)
- return ranNamesToBeDissociated, nil
-}
-
func (m E2TShutdownManager) markE2tInstanceToBeDeleted(e2tInstance *entities.E2TInstance) error {
e2tInstance.State = entities.ToBeDeleted
e2tInstance.DeletionTimestamp = time.Now().UnixNano()
"e2mgr/clients"
"e2mgr/configuration"
"e2mgr/e2managererrors"
- "e2mgr/e2pdus"
"e2mgr/mocks"
"e2mgr/models"
- "e2mgr/rmrCgo"
"e2mgr/services"
"encoding/json"
"fmt"
const E2TAddress3 = "10.10.2.17:9800"
-func initE2TShutdownManagerTest(t *testing.T) (*E2TShutdownManager, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.HttpClientMock, *mocks.RmrMessengerMock) {
+func initE2TShutdownManagerTest(t *testing.T) (*E2TShutdownManager, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.HttpClientMock) {
log := initLog(t)
config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3, E2TInstanceDeletionTimeoutMs: 15000}
httpClientMock := &mocks.HttpClientMock{}
rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
associationManager := NewE2TAssociationManager(log, rnibDataService, e2tInstancesManager, rmClient)
- rmrMessengerMock := &mocks.RmrMessengerMock{}
- rmrSender := initRmrSender(rmrMessengerMock, log)
- ranSetupManager := NewRanSetupManager(log, rmrSender, rnibDataService)
- shutdownManager := NewE2TShutdownManager(log, config, rnibDataService, e2tInstancesManager, associationManager, ranSetupManager)
- return shutdownManager, readerMock, writerMock, httpClientMock, rmrMessengerMock
+ shutdownManager := NewE2TShutdownManager(log, config, rnibDataService, e2tInstancesManager, associationManager)
+
+ return shutdownManager, readerMock, writerMock, httpClientMock
}
func TestShutdownSuccess1OutOf3Instances(t *testing.T) {
- shutdownManager, readerMock, writerMock, httpClientMock, rmrMessengerMock := initE2TShutdownManagerTest(t)
+ shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
e2tInstance1 := entities.NewE2TInstance(E2TAddress)
e2tInstance1.State = entities.Active
e2tAddresses := []string{E2TAddress, E2TAddress2,E2TAddress3}
readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
- readerMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{e2tInstance2,e2tInstance3}, nil)
- e2tDataList := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress2, "test1", "test5")}
- data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, nil, e2tDataList)
+ data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, e2tInstance1.AssociatedRanList, nil)
marshaled, _ := json.Marshal(data)
body := bytes.NewBuffer(marshaled)
respBody := ioutil.NopCloser(bytes.NewBufferString(""))
writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
writerMock.On("SaveE2TAddresses", []string{E2TAddress2,E2TAddress3}).Return(nil)
- readerMock.On("GetE2TInstance", E2TAddress2).Return(e2tInstance2, nil)
- e2tInstance2updated := *e2tInstance2
- e2tInstance2updated.AssociatedRanList = append(e2tInstance2updated.AssociatedRanList, "test1", "test5")
- writerMock.On("SaveE2TInstance", &e2tInstance2updated).Return(nil)
-
- nodeb1new := *nodeb1
- nodeb1new.AssociatedE2TInstanceAddress = E2TAddress2
- nodeb1new.ConnectionStatus = entities.ConnectionStatus_CONNECTING
- nodeb1new.ConnectionAttempts = 1
- writerMock.On("UpdateNodebInfo", &nodeb1new).Return(nil)
- nodeb5new := *nodeb5
- nodeb5new.AssociatedE2TInstanceAddress = E2TAddress2
- nodeb5new.ConnectionStatus = entities.ConnectionStatus_CONNECTING
- nodeb5new.ConnectionAttempts = 1
- writerMock.On("UpdateNodebInfo", &nodeb5new).Return(nil)
-
nodeb1connected := *nodeb1
- nodeb1connected.AssociatedE2TInstanceAddress = E2TAddress2
- nodeb1connected.ConnectionStatus = entities.ConnectionStatus_CONNECTED
+ nodeb1connected.AssociatedE2TInstanceAddress = ""
+ nodeb1connected.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
writerMock.On("UpdateNodebInfo", &nodeb1connected).Return(nil)
+ nodeb2connected := *nodeb2
+ nodeb2connected.AssociatedE2TInstanceAddress = ""
+ nodeb2connected.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
+ writerMock.On("UpdateNodebInfo", &nodeb2connected).Return(nil)
nodeb5connected := *nodeb5
- nodeb5connected.AssociatedE2TInstanceAddress = E2TAddress2
- nodeb5connected.ConnectionStatus = entities.ConnectionStatus_CONNECTED
+ nodeb5connected.AssociatedE2TInstanceAddress = ""
+ nodeb5connected.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
writerMock.On("UpdateNodebInfo", &nodeb5connected).Return(nil)
- payload := e2pdus.PackedX2setupRequest
- xaction1 := []byte("test1")
- msg1 := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), "test1", &payload, &xaction1)
- rmrMessengerMock.On("SendMsg",mock.Anything, true).Return(msg1, nil)
- xaction5 := []byte("test5")
- msg5 := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), "test5", &payload, &xaction5)
- rmrMessengerMock.On("SendMsg",mock.Anything, true).Return(msg5, nil)
-
err := shutdownManager.Shutdown(e2tInstance1)
assert.Nil(t, err)
readerMock.AssertExpectations(t)
writerMock.AssertExpectations(t)
httpClientMock.AssertExpectations(t)
- rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 2)
}
func TestShutdownSuccess1InstanceWithoutRans(t *testing.T) {
- shutdownManager, readerMock, writerMock, httpClientMock, rmrMessengerMock := initE2TShutdownManagerTest(t)
+ shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
e2tInstance1 := entities.NewE2TInstance(E2TAddress)
e2tInstance1.State = entities.Active
readerMock.AssertExpectations(t)
writerMock.AssertExpectations(t)
httpClientMock.AssertExpectations(t)
- rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 0)
}
func TestShutdownSuccess1Instance2Rans(t *testing.T) {
- shutdownManager, readerMock, writerMock, httpClientMock, rmrMessengerMock := initE2TShutdownManagerTest(t)
+ shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
e2tInstance1 := entities.NewE2TInstance(E2TAddress)
e2tInstance1.State = entities.Active
respBody := ioutil.NopCloser(bytes.NewBufferString(""))
httpClientMock.On("Delete", "e2t", "application/json", body).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
- e2tInstance1updated := *e2tInstance1
- e2tInstance1updated.State = entities.ToBeDeleted
- readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance1updated}, nil)
-
writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
writerMock.On("SaveE2TAddresses", []string{}).Return(nil)
readerMock.AssertExpectations(t)
writerMock.AssertExpectations(t)
httpClientMock.AssertExpectations(t)
- rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 0)
+
}
-
-
func TestShutdownE2tInstanceAlreadyBeingDeleted(t *testing.T) {
- shutdownManager, readerMock, writerMock, httpClientMock, rmrMessengerMock := initE2TShutdownManagerTest(t)
+ shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
e2tInstance1 := entities.NewE2TInstance(E2TAddress)
e2tInstance1.State = entities.ToBeDeleted
readerMock.AssertExpectations(t)
writerMock.AssertExpectations(t)
httpClientMock.AssertExpectations(t)
- rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 0)
+
}
func TestShutdownFailureMarkInstanceAsToBeDeleted(t *testing.T) {
- shutdownManager, readerMock, writerMock, httpClientMock, rmrMessengerMock := initE2TShutdownManagerTest(t)
+ shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
e2tInstance1 := entities.NewE2TInstance(E2TAddress)
e2tInstance1.State = entities.Active
readerMock.AssertExpectations(t)
writerMock.AssertExpectations(t)
httpClientMock.AssertExpectations(t)
- rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 0)
-}
-
-func TestShutdownFailureReassociatingInMemoryNodebNotFound(t *testing.T) {
- shutdownManager, readerMock, writerMock, httpClientMock, rmrMessengerMock := initE2TShutdownManagerTest(t)
-
- e2tInstance1 := entities.NewE2TInstance(E2TAddress)
- e2tInstance1.State = entities.Active
- e2tInstance1.AssociatedRanList = []string{"test1", "test2"}
- e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
- e2tInstance2.State = entities.Active
- e2tInstance2.AssociatedRanList = []string{"test3"}
- writerMock.On("SaveE2TInstance", mock.MatchedBy(func(e2tInstance *entities.E2TInstance) bool { return e2tInstance.Address == E2TAddress && e2tInstance.State == entities.ToBeDeleted })).Return(nil)
-
- var nodeb1 *entities.NodebInfo
- readerMock.On("GetNodeb", "test1").Return(nodeb1, common.NewResourceNotFoundError("for tests"))
- nodeb2 := &entities.NodebInfo{RanName:"test2", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
- readerMock.On("GetNodeb", "test2").Return(nodeb2, nil)
-
- e2tAddresses := []string{E2TAddress, E2TAddress2}
- readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
- readerMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{e2tInstance2}, nil)
-
- e2tDataList := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress2, "test2")}
- data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, nil, e2tDataList)
- marshaled, _ := json.Marshal(data)
- body := bytes.NewBuffer(marshaled)
- respBody := ioutil.NopCloser(bytes.NewBufferString(""))
- httpClientMock.On("Delete", "e2t", "application/json", body).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
-
- writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
- writerMock.On("SaveE2TAddresses", []string{E2TAddress2}).Return(nil)
-
- readerMock.On("GetE2TInstance", E2TAddress2).Return(e2tInstance2, nil)
- e2tInstance2updated := *e2tInstance2
- e2tInstance2updated.AssociatedRanList = append(e2tInstance2updated.AssociatedRanList, "test2")
- writerMock.On("SaveE2TInstance", &e2tInstance2updated).Return(nil)
-
- nodeb2new := *nodeb2
- nodeb2new.AssociatedE2TInstanceAddress = E2TAddress2
- nodeb2new.ConnectionStatus = entities.ConnectionStatus_CONNECTING
- nodeb2new.ConnectionAttempts = 1
- writerMock.On("UpdateNodebInfo", &nodeb2new).Return(nil)
-
- nodeb2connected := *nodeb2
- nodeb2connected.AssociatedE2TInstanceAddress = E2TAddress2
- nodeb2connected.ConnectionStatus = entities.ConnectionStatus_CONNECTED
- writerMock.On("UpdateNodebInfo", &nodeb2connected).Return(nil)
-
- payload := e2pdus.PackedX2setupRequest
- xaction2 := []byte("test2")
- msg2 := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), "test2", &payload, &xaction2)
- rmrMessengerMock.On("SendMsg",mock.Anything, true).Return(msg2, nil)
-
- err := shutdownManager.Shutdown(e2tInstance1)
-
- assert.Nil(t, err)
- readerMock.AssertExpectations(t)
- writerMock.AssertExpectations(t)
- httpClientMock.AssertExpectations(t)
- rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 1)
-}
-
-func TestShutdownFailureReassociatingInMemoryGetNodebError(t *testing.T) {
- shutdownManager, readerMock, writerMock, httpClientMock, rmrMessengerMock := initE2TShutdownManagerTest(t)
-
- e2tInstance1 := entities.NewE2TInstance(E2TAddress)
- e2tInstance1.State = entities.Active
- e2tInstance1.AssociatedRanList = []string{"test1", "test2"}
- e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
- e2tInstance2.State = entities.Active
- e2tInstance2.AssociatedRanList = []string{"test3"}
- writerMock.On("SaveE2TInstance", mock.MatchedBy(func(e2tInstance *entities.E2TInstance) bool { return e2tInstance.Address == E2TAddress && e2tInstance.State == entities.ToBeDeleted })).Return(nil)
-
- var nodeb1 *entities.NodebInfo
- readerMock.On("GetNodeb", "test1").Return(nodeb1, common.NewInternalError(fmt.Errorf("for tests")))
-
- err := shutdownManager.Shutdown(e2tInstance1)
-
- assert.NotNil(t, err)
- readerMock.AssertExpectations(t)
- writerMock.AssertExpectations(t)
- httpClientMock.AssertExpectations(t)
- rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 0)
+
}
func TestShutdownFailureRoutingManagerError(t *testing.T) {
- shutdownManager, readerMock, writerMock, httpClientMock, rmrMessengerMock := initE2TShutdownManagerTest(t)
+ shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
e2tInstance1 := entities.NewE2TInstance(E2TAddress)
e2tInstance1.State = entities.Active
e2tAddresses := []string{E2TAddress, E2TAddress2,E2TAddress3}
readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
- readerMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{e2tInstance2,e2tInstance3}, nil)
- e2tDataList := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress2, "test1", "test5")}
- data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, nil, e2tDataList)
+ data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, e2tInstance1.AssociatedRanList, nil)
marshaled, _ := json.Marshal(data)
body := bytes.NewBuffer(marshaled)
respBody := ioutil.NopCloser(bytes.NewBufferString(""))
httpClientMock.On("Delete", "e2t", "application/json", body).Return(&http.Response{StatusCode: http.StatusBadRequest, Body: respBody}, nil)
- readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, nil)
- writerMock.On("SaveE2TInstance", mock.MatchedBy(func(e2tInstance *entities.E2TInstance) bool { return e2tInstance.Address == E2TAddress && e2tInstance.State == entities.RoutingManagerFailure })).Return(nil)
+ writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
+ writerMock.On("SaveE2TAddresses", []string{E2TAddress2,E2TAddress3}).Return(nil)
+
+ nodeb1connected := *nodeb1
+ nodeb1connected.AssociatedE2TInstanceAddress = ""
+ nodeb1connected.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
+ writerMock.On("UpdateNodebInfo", &nodeb1connected).Return(nil)
+ nodeb2connected := *nodeb2
+ nodeb2connected.AssociatedE2TInstanceAddress = ""
+ nodeb2connected.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
+ writerMock.On("UpdateNodebInfo", &nodeb2connected).Return(nil)
+ nodeb5connected := *nodeb5
+ nodeb5connected.AssociatedE2TInstanceAddress = ""
+ nodeb5connected.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
+ writerMock.On("UpdateNodebInfo", &nodeb5connected).Return(nil)
err := shutdownManager.Shutdown(e2tInstance1)
- assert.NotNil(t, err)
+ assert.Nil(t, err)
readerMock.AssertExpectations(t)
writerMock.AssertExpectations(t)
httpClientMock.AssertExpectations(t)
- rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 0)
+
}
func TestShutdownFailureInClearNodebsAssociation(t *testing.T) {
- shutdownManager, readerMock, writerMock, httpClientMock, rmrMessengerMock := initE2TShutdownManagerTest(t)
+ shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
e2tInstance1 := entities.NewE2TInstance(E2TAddress)
e2tInstance1.State = entities.Active
nodeb1 := &entities.NodebInfo{RanName:"test1", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
readerMock.On("GetNodeb", "test1").Return(nodeb1, nil)
- nodeb2 := &entities.NodebInfo{RanName:"test2", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
- readerMock.On("GetNodeb", "test2").Return(nodeb2, nil)
-
- data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1", "test2"}, nil)
- marshaled, _ := json.Marshal(data)
- body := bytes.NewBuffer(marshaled)
- respBody := ioutil.NopCloser(bytes.NewBufferString(""))
- httpClientMock.On("Delete", "e2t", "application/json", body).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
-
- e2tInstance1updated := *e2tInstance1
- e2tInstance1updated.State = entities.ToBeDeleted
- readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance1updated}, nil)
-
- writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
- readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
- writerMock.On("SaveE2TAddresses", []string{}).Return(nil)
nodeb1new := *nodeb1
nodeb1new.AssociatedE2TInstanceAddress = ""
readerMock.AssertExpectations(t)
writerMock.AssertExpectations(t)
httpClientMock.AssertExpectations(t)
- rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 0)
}
-func TestShutdownFailureInRmr(t *testing.T) {
- shutdownManager, readerMock, writerMock, httpClientMock, rmrMessengerMock := initE2TShutdownManagerTest(t)
+func TestShutdownResourceNotFoundErrorInGetNodeb(t *testing.T) {
+ shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
e2tInstance1 := entities.NewE2TInstance(E2TAddress)
e2tInstance1.State = entities.Active
- e2tInstance1.AssociatedRanList = []string{"test1", "test2", "test5"}
- e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
- e2tInstance2.State = entities.Active
- e2tInstance2.AssociatedRanList = []string{"test3"}
- e2tInstance3 := entities.NewE2TInstance(E2TAddress3)
- e2tInstance3.State = entities.Active
- e2tInstance3.AssociatedRanList = []string{"test4"}
+ e2tInstance1.AssociatedRanList = []string{"test1", "test2"}
writerMock.On("SaveE2TInstance", mock.MatchedBy(func(e2tInstance *entities.E2TInstance) bool { return e2tInstance.Address == E2TAddress && e2tInstance.State == entities.ToBeDeleted })).Return(nil)
nodeb1 := &entities.NodebInfo{RanName:"test1", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
readerMock.On("GetNodeb", "test1").Return(nodeb1, nil)
- nodeb2 := &entities.NodebInfo{RanName:"test2", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
- readerMock.On("GetNodeb", "test2").Return(nodeb2, nil)
- nodeb5 := &entities.NodebInfo{RanName:"test5", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
- readerMock.On("GetNodeb", "test5").Return(nodeb5, nil)
-
- e2tAddresses := []string{E2TAddress, E2TAddress2,E2TAddress3}
- readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
- readerMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{e2tInstance2,e2tInstance3}, nil)
-
- e2tDataList := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress2, "test1", "test5")}
- data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, nil, e2tDataList)
- marshaled, _ := json.Marshal(data)
- body := bytes.NewBuffer(marshaled)
- respBody := ioutil.NopCloser(bytes.NewBufferString(""))
- httpClientMock.On("Delete", "e2t", "application/json", body).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
-
- writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
- writerMock.On("SaveE2TAddresses", []string{E2TAddress2,E2TAddress3}).Return(nil)
-
- readerMock.On("GetE2TInstance", E2TAddress2).Return(e2tInstance2, nil)
- e2tInstance2updated := *e2tInstance2
- e2tInstance2updated.AssociatedRanList = []string{"test3", "test1", "test5"}
- writerMock.On("SaveE2TInstance", &e2tInstance2updated).Return(nil)
-
- nodeb1reassigned := *nodeb1
- nodeb1reassigned.AssociatedE2TInstanceAddress = E2TAddress2
- writerMock.On("UpdateNodebInfo", &nodeb1reassigned).Return(nil)
- nodeb5reassigned := *nodeb5
- nodeb5reassigned.AssociatedE2TInstanceAddress = E2TAddress2
- writerMock.On("UpdateNodebInfo", &nodeb5reassigned).Return(nil)
+ var nodeb2 *entities.NodebInfo
+ readerMock.On("GetNodeb", "test2").Return(nodeb2, common.NewResourceNotFoundError("for testing"))
nodeb1new := *nodeb1
- nodeb1new.AssociatedE2TInstanceAddress = E2TAddress2
- nodeb1new.ConnectionStatus = entities.ConnectionStatus_CONNECTING
- nodeb1new.ConnectionAttempts = 1
+ nodeb1new.AssociatedE2TInstanceAddress = ""
+ nodeb1new.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
writerMock.On("UpdateNodebInfo", &nodeb1new).Return(nil)
- nodeb5new := *nodeb5
- nodeb5new.AssociatedE2TInstanceAddress = E2TAddress2
- nodeb5new.ConnectionStatus = entities.ConnectionStatus_CONNECTING
- nodeb5new.ConnectionAttempts = 1
- writerMock.On("UpdateNodebInfo", &nodeb5new).Return(nil)
-
- nodeb1connected := *nodeb1
- nodeb1connected.AssociatedE2TInstanceAddress = E2TAddress2
- nodeb1connected.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
- nodeb1connected.ConnectionAttempts = 0
- //nodeb1connected.E2ApplicationProtocol = entities.E2ApplicationProtocol_X2_SETUP_REQUEST
- writerMock.On("UpdateNodebInfo", &nodeb1connected).Return(nil)
- nodeb5connected := *nodeb5
- nodeb5connected.AssociatedE2TInstanceAddress = E2TAddress2
- nodeb5connected.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
- nodeb5connected.ConnectionAttempts = 0
- //nodeb5connected.E2ApplicationProtocol = entities.E2ApplicationProtocol_X2_SETUP_REQUEST
- writerMock.On("UpdateNodebInfo", &nodeb5connected).Return(nil)
-
- payload := e2pdus.PackedX2setupRequest
- xaction1 := []byte("test1")
- msg1 := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), "test1", &payload, &xaction1)
- rmrMessengerMock.On("SendMsg",mock.Anything, true).Return(msg1, common.NewInternalError(fmt.Errorf("for test")))
- xaction2 := []byte("test5")
- msg2 := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), "test5", &payload, &xaction2)
- rmrMessengerMock.On("SendMsg",mock.Anything, true).Return(msg2, common.NewInternalError(fmt.Errorf("for test")))
err := shutdownManager.Shutdown(e2tInstance1)
- assert.Nil(t, err)
+ assert.NotNil(t, err)
readerMock.AssertExpectations(t)
writerMock.AssertExpectations(t)
httpClientMock.AssertExpectations(t)
- rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 2)
}
-func TestShutdownFailureDbErrorInAsociateAndSetupNodebs(t *testing.T) {
- shutdownManager, readerMock, writerMock, httpClientMock, rmrMessengerMock := initE2TShutdownManagerTest(t)
+func TestShutdownResourceGeneralErrorInGetNodeb(t *testing.T) {
+ shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
e2tInstance1 := entities.NewE2TInstance(E2TAddress)
e2tInstance1.State = entities.Active
- e2tInstance1.AssociatedRanList = []string{"test1", "test2", "test5"}
- e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
- e2tInstance2.State = entities.Active
- e2tInstance2.AssociatedRanList = []string{"test3"}
- e2tInstance3 := entities.NewE2TInstance(E2TAddress3)
- e2tInstance3.State = entities.Active
- e2tInstance3.AssociatedRanList = []string{"test4"}
+ e2tInstance1.AssociatedRanList = []string{"test1", "test2"}
writerMock.On("SaveE2TInstance", mock.MatchedBy(func(e2tInstance *entities.E2TInstance) bool { return e2tInstance.Address == E2TAddress && e2tInstance.State == entities.ToBeDeleted })).Return(nil)
- nodeb1 := &entities.NodebInfo{RanName:"test1", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
- readerMock.On("GetNodeb", "test1").Return(nodeb1, nil)
- nodeb2 := &entities.NodebInfo{RanName:"test2", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
+ var nodeb1 *entities.NodebInfo
+ readerMock.On("GetNodeb", "test1").Return(nodeb1, common.NewInternalError(fmt.Errorf("for testing")))
+ nodeb2 := &entities.NodebInfo{RanName:"test2", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
readerMock.On("GetNodeb", "test2").Return(nodeb2, nil)
- nodeb5 := &entities.NodebInfo{RanName:"test5", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
- readerMock.On("GetNodeb", "test5").Return(nodeb5, nil)
-
- e2tAddresses := []string{E2TAddress, E2TAddress2,E2TAddress3}
- readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
- readerMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{e2tInstance2,e2tInstance3}, nil)
- e2tDataList := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress2, "test1", "test5")}
- data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, nil, e2tDataList)
+ data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1", "test2"}, nil)
marshaled, _ := json.Marshal(data)
body := bytes.NewBuffer(marshaled)
respBody := ioutil.NopCloser(bytes.NewBufferString(""))
httpClientMock.On("Delete", "e2t", "application/json", body).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
- writerMock.On("SaveE2TAddresses", []string{E2TAddress2,E2TAddress3}).Return(nil)
-
- readerMock.On("GetE2TInstance", E2TAddress2).Return(e2tInstance2, nil)
- e2tInstance2updated := *e2tInstance2
- e2tInstance2updated.AssociatedRanList = []string{"test3", "test1", "test5"}
- writerMock.On("SaveE2TInstance", &e2tInstance2updated).Return(nil)
+ readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
+ writerMock.On("SaveE2TAddresses", []string{}).Return(nil)
- nodeb1reassigned := *nodeb1
- nodeb1reassigned.AssociatedE2TInstanceAddress = E2TAddress2
- writerMock.On("UpdateNodebInfo", &nodeb1reassigned).Return(common.NewInternalError(fmt.Errorf("for tests")))
+ nodeb2new := *nodeb2
+ nodeb2new.AssociatedE2TInstanceAddress = ""
+ nodeb2new.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
+ writerMock.On("UpdateNodebInfo", &nodeb2new).Return(nil)
err := shutdownManager.Shutdown(e2tInstance1)
- assert.NotNil(t, err)
+ assert.Nil(t, err)
readerMock.AssertExpectations(t)
writerMock.AssertExpectations(t)
httpClientMock.AssertExpectations(t)
- rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 0)
+
}
-func TestShutdownSuccess1OutOf3InstancesStateIsRoutingManagerFailure(t *testing.T) {
- shutdownManager, readerMock, writerMock, httpClientMock, rmrMessengerMock := initE2TShutdownManagerTest(t)
+func TestShutdownFailureInRemoveE2TInstance(t *testing.T) {
+ shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
e2tInstance1 := entities.NewE2TInstance(E2TAddress)
- e2tInstance1.State = entities.RoutingManagerFailure
+ e2tInstance1.State = entities.Active
e2tInstance1.AssociatedRanList = []string{"test1", "test2", "test5"}
e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
e2tInstance2.State = entities.Active
nodeb5 := &entities.NodebInfo{RanName:"test5", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
readerMock.On("GetNodeb", "test5").Return(nodeb5, nil)
- e2tAddresses := []string{E2TAddress, E2TAddress2,E2TAddress3}
- readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
- readerMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{e2tInstance2,e2tInstance3}, nil)
-
- e2tDataList := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress2, "test1", "test5")}
- data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, nil, e2tDataList)
+ data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, e2tInstance1.AssociatedRanList, nil)
marshaled, _ := json.Marshal(data)
body := bytes.NewBuffer(marshaled)
respBody := ioutil.NopCloser(bytes.NewBufferString(""))
httpClientMock.On("Delete", "e2t", "application/json", body).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
- writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
- writerMock.On("SaveE2TAddresses", []string{E2TAddress2,E2TAddress3}).Return(nil)
-
- readerMock.On("GetE2TInstance", E2TAddress2).Return(e2tInstance2, nil)
- e2tInstance2updated := *e2tInstance2
- e2tInstance2updated.AssociatedRanList = []string{"test3", "test1", "test5"}
- writerMock.On("SaveE2TInstance", &e2tInstance2updated).Return(nil)
-
- nodeb1new := *nodeb1
- nodeb1new.AssociatedE2TInstanceAddress = E2TAddress2
- nodeb1new.ConnectionStatus = entities.ConnectionStatus_CONNECTING
- nodeb1new.ConnectionAttempts = 1
- writerMock.On("UpdateNodebInfo", &nodeb1new).Return(nil)
- nodeb5new := *nodeb5
- nodeb5new.AssociatedE2TInstanceAddress = E2TAddress2
- nodeb5new.ConnectionStatus = entities.ConnectionStatus_CONNECTING
- nodeb5new.ConnectionAttempts = 1
- writerMock.On("UpdateNodebInfo", &nodeb5new).Return(nil)
+ writerMock.On("RemoveE2TInstance", E2TAddress).Return(common.NewInternalError(fmt.Errorf("for tests")))
nodeb1connected := *nodeb1
- nodeb1connected.AssociatedE2TInstanceAddress = E2TAddress2
- nodeb1connected.ConnectionStatus = entities.ConnectionStatus_CONNECTED
- //nodeb1connected.E2ApplicationProtocol = entities.E2ApplicationProtocol_X2_SETUP_REQUEST
+ nodeb1connected.AssociatedE2TInstanceAddress = ""
+ nodeb1connected.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
writerMock.On("UpdateNodebInfo", &nodeb1connected).Return(nil)
+ nodeb2connected := *nodeb2
+ nodeb2connected.AssociatedE2TInstanceAddress = ""
+ nodeb2connected.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
+ writerMock.On("UpdateNodebInfo", &nodeb2connected).Return(nil)
nodeb5connected := *nodeb5
- nodeb5connected.AssociatedE2TInstanceAddress = E2TAddress2
- nodeb5connected.ConnectionStatus = entities.ConnectionStatus_CONNECTED
- //nodeb5connected.E2ApplicationProtocol = entities.E2ApplicationProtocol_X2_SETUP_REQUEST
+ nodeb5connected.AssociatedE2TInstanceAddress = ""
+ nodeb5connected.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
writerMock.On("UpdateNodebInfo", &nodeb5connected).Return(nil)
- payload := e2pdus.PackedX2setupRequest
- xaction1 := []byte("test1")
- msg1 := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), "test1", &payload, &xaction1)
- rmrMessengerMock.On("SendMsg",mock.Anything, true).Return(msg1, nil)
- xaction5 := []byte("test5")
- msg5 := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), "test5", &payload, &xaction5)
- rmrMessengerMock.On("SendMsg",mock.Anything, true).Return(msg5, nil)
-
err := shutdownManager.Shutdown(e2tInstance1)
- assert.Nil(t, err)
+ assert.IsType(t, &e2managererrors.RnibDbError{}, err)
readerMock.AssertExpectations(t)
writerMock.AssertExpectations(t)
httpClientMock.AssertExpectations(t)
- rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 2)
}
\ No newline at end of file
return args.Error(0)
}
-func (m *RoutingManagerClientMock) DeleteE2TInstance(e2tAddress string, ransToBeDissociated []string, e2tToRansAssociations map[string][]string) error {
+func (m *RoutingManagerClientMock) DeleteE2TInstance(e2tAddress string, ransToBeDissociated []string) error {
- args := m.Called(e2tAddress, ransToBeDissociated, e2tToRansAssociations)
+ args := m.Called(e2tAddress, ransToBeDissociated)
return args.Error(0)
}
\ No newline at end of file
Code Review / ric-plt / e2mgr.git / commitdiff