Merge "Changing status to connected state after timeout."

[ric-plt/e2mgr.git] / E2Manager / managers / e2t_instances_manager_test.go

diff --git a/E2Manager/managers/e2t_instances_manager_test.go b/E2Manager/managers/e2t_instances_manager_test.go
index fb564e5..380ac05 100644 (file)
--- a/E2Manager/managers/e2t_instances_manager_test.go
+++ b/E2Manager/managers/e2t_instances_manager_test.go
@@ -13,11 +13,15 @@
 // 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 managers
 
 import (
        "e2mgr/configuration"
+       "e2mgr/e2managererrors"
        "e2mgr/logger"
        "e2mgr/mocks"
        "e2mgr/services"
@@ -32,9 +36,11 @@ import (
 
 const E2TAddress = "10.10.2.15:9800"
 const E2TAddress2 = "10.10.2.16:9800"
+const PodName = "som_ pod_name"
 
 func initE2TInstancesManagerTest(t *testing.T) (*mocks.RnibReaderMock, *mocks.RnibWriterMock, *E2TInstancesManager) {
-       logger, err := logger.InitLogger(logger.DebugLevel)
+       DebugLevel := int8(4)
+       logger, err := logger.InitLogger(DebugLevel)
        if err != nil {
                t.Errorf("#... - failed to initialize logger, error: %s", err)
        }
@@ -50,7 +56,7 @@ func initE2TInstancesManagerTest(t *testing.T) (*mocks.RnibReaderMock, *mocks.Rn
 func TestAddNewE2TInstanceSaveE2TInstanceFailure(t *testing.T) {
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
        rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(errors.New("Error")))
-       err := e2tInstancesManager.AddE2TInstance(E2TAddress)
+       err := e2tInstancesManager.AddE2TInstance(E2TAddress, PodName)
        assert.NotNil(t, err)
        rnibReaderMock.AssertNotCalled(t, "GetE2TAddresses")
 }
@@ -60,7 +66,7 @@ func TestAddNewE2TInstanceGetE2TAddressesInternalFailure(t *testing.T) {
        rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
        e2tAddresses := []string{}
        rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, common.NewInternalError(errors.New("Error")))
-       err := e2tInstancesManager.AddE2TInstance(E2TAddress)
+       err := e2tInstancesManager.AddE2TInstance(E2TAddress, PodName)
        assert.NotNil(t, err)
        rnibReaderMock.AssertNotCalled(t, "SaveE2TAddresses")
 }
@@ -72,7 +78,7 @@ func TestAddNewE2TInstanceSaveE2TAddressesFailure(t *testing.T) {
        rnibReaderMock.On("GetE2TAddresses").Return(E2TAddresses, nil)
        E2TAddresses = append(E2TAddresses, E2TAddress)
        rnibWriterMock.On("SaveE2TAddresses", E2TAddresses).Return(common.NewResourceNotFoundError(""))
-       err := e2tInstancesManager.AddE2TInstance(E2TAddress)
+       err := e2tInstancesManager.AddE2TInstance(E2TAddress, PodName)
        assert.NotNil(t, err)
 }
 
@@ -83,7 +89,7 @@ func TestAddNewE2TInstanceNoE2TAddressesSuccess(t *testing.T) {
        rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, common.NewResourceNotFoundError(""))
        e2tAddresses = append(e2tAddresses, E2TAddress)
        rnibWriterMock.On("SaveE2TAddresses", e2tAddresses).Return(nil)
-       err := e2tInstancesManager.AddE2TInstance(E2TAddress)
+       err := e2tInstancesManager.AddE2TInstance(E2TAddress, PodName)
        assert.Nil(t, err)
        rnibWriterMock.AssertCalled(t, "SaveE2TAddresses", e2tAddresses)
 }
@@ -95,7 +101,7 @@ func TestAddNewE2TInstanceEmptyE2TAddressesSuccess(t *testing.T) {
        rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
        e2tAddresses = append(e2tAddresses, E2TAddress)
        rnibWriterMock.On("SaveE2TAddresses", e2tAddresses).Return(nil)
-       err := e2tInstancesManager.AddE2TInstance(E2TAddress)
+       err := e2tInstancesManager.AddE2TInstance(E2TAddress, PodName)
        assert.Nil(t, err)
        rnibWriterMock.AssertCalled(t, "SaveE2TAddresses", e2tAddresses)
 }
@@ -107,7 +113,7 @@ func TestAddNewE2TInstanceExistingE2TAddressesSuccess(t *testing.T) {
        rnibReaderMock.On("GetE2TAddresses").Return(E2TAddresses, nil)
        E2TAddresses = append(E2TAddresses, E2TAddress)
        rnibWriterMock.On("SaveE2TAddresses", E2TAddresses).Return(nil)
-       err := e2tInstancesManager.AddE2TInstance(E2TAddress)
+       err := e2tInstancesManager.AddE2TInstance(E2TAddress, PodName)
        assert.Nil(t, err)
 }
 
@@ -123,39 +129,39 @@ func TestGetE2TInstanceFailure(t *testing.T) {
 func TestGetE2TInstanceSuccess(t *testing.T) {
        rnibReaderMock, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
        address := "10.10.2.15:9800"
-       e2tInstance := entities.NewE2TInstance(address)
+       e2tInstance := entities.NewE2TInstance(address, PodName)
        rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
        res, err := e2tInstancesManager.GetE2TInstance(address)
        assert.Nil(t, err)
        assert.Equal(t, e2tInstance, res)
 }
 
-func TestAssociateRanGetInstanceFailure(t *testing.T) {
+func TestAddRanToInstanceGetInstanceFailure(t *testing.T) {
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 
        var e2tInstance1 *entities.E2TInstance
        rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, common.NewInternalError(fmt.Errorf("for test")))
 
-       err := e2tInstancesManager.AssociateRan("test1", E2TAddress)
+       err := e2tInstancesManager.AddRansToInstance(E2TAddress, []string{"test1"})
        assert.NotNil(t, err)
        rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
 }
 
-func TestAssociateRanSaveInstanceFailure(t *testing.T) {
+func TestAddRanToInstanceSaveInstanceFailure(t *testing.T) {
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
-       e2tInstance1 := entities.NewE2TInstance(E2TAddress)
+       e2tInstance1 := entities.NewE2TInstance(E2TAddress, PodName)
        rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, nil)
        rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(fmt.Errorf("for test")))
 
-       err := e2tInstancesManager.AssociateRan("test1", E2TAddress)
+       err := e2tInstancesManager.AddRansToInstance(E2TAddress, []string{"test1"})
        assert.NotNil(t, err)
        rnibReaderMock.AssertExpectations(t)
        rnibWriterMock.AssertExpectations(t)
 }
 
-func TestAssociateRanSuccess(t *testing.T) {
+func TestAddRanToInstanceSuccess(t *testing.T) {
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
-       e2tInstance := entities.NewE2TInstance(E2TAddress)
+       e2tInstance := entities.NewE2TInstance(E2TAddress, PodName)
        rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
 
        updateE2TInstance := *e2tInstance
@@ -163,46 +169,46 @@ func TestAssociateRanSuccess(t *testing.T) {
 
        rnibWriterMock.On("SaveE2TInstance", &updateE2TInstance).Return(nil)
 
-       err := e2tInstancesManager.AssociateRan("test1", E2TAddress)
+       err := e2tInstancesManager.AddRansToInstance(E2TAddress, []string{"test1"})
        assert.Nil(t, err)
        rnibReaderMock.AssertExpectations(t)
        rnibWriterMock.AssertExpectations(t)
 }
 
-func TestDissociateRanGetInstanceFailure(t *testing.T) {
+func TestRemoveRanFromInstanceGetInstanceFailure(t *testing.T) {
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 
        var e2tInstance1 *entities.E2TInstance
        rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, common.NewInternalError(fmt.Errorf("for test")))
-       err := e2tInstancesManager.DissociateRan("test1", E2TAddress)
+       err := e2tInstancesManager.RemoveRanFromInstance("test1", E2TAddress)
        assert.NotNil(t, err)
        rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
 }
 
-func TestDissociateRanSaveInstanceFailure(t *testing.T) {
+func TestRemoveRanFromInstanceSaveInstanceFailure(t *testing.T) {
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 
-       e2tInstance1 := entities.NewE2TInstance(E2TAddress)
+       e2tInstance1 := entities.NewE2TInstance(E2TAddress, PodName)
        rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, nil)
        rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(fmt.Errorf("for test")))
 
-       err := e2tInstancesManager.DissociateRan("test1", E2TAddress)
+       err := e2tInstancesManager.RemoveRanFromInstance("test1", E2TAddress)
        assert.NotNil(t, err)
        rnibReaderMock.AssertExpectations(t)
        rnibWriterMock.AssertExpectations(t)
 }
 
-func TestDissociateRanSuccess(t *testing.T) {
+func TestRemoveRanFromInstanceSuccess(t *testing.T) {
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 
-       e2tInstance := entities.NewE2TInstance(E2TAddress)
+       e2tInstance := entities.NewE2TInstance(E2TAddress, PodName)
        e2tInstance.AssociatedRanList = []string{"test0", "test1"}
        updatedE2TInstance := *e2tInstance
        updatedE2TInstance.AssociatedRanList = []string{"test0"}
        rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
        rnibWriterMock.On("SaveE2TInstance", &updatedE2TInstance).Return(nil)
 
-       err := e2tInstancesManager.DissociateRan("test1", E2TAddress)
+       err := e2tInstancesManager.RemoveRanFromInstance("test1", E2TAddress)
        assert.Nil(t, err)
        rnibReaderMock.AssertExpectations(t)
        rnibWriterMock.AssertExpectations(t)
@@ -259,10 +265,10 @@ func TestSelectE2TInstancesEmptyE2TInstancesList(t *testing.T) {
 func TestSelectE2TInstancesNoActiveE2TInstance(t *testing.T) {
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
        addresses := []string{E2TAddress, E2TAddress2}
-       e2tInstance1 := entities.NewE2TInstance(E2TAddress)
+       e2tInstance1 := entities.NewE2TInstance(E2TAddress, PodName)
        e2tInstance1.State = entities.ToBeDeleted
        e2tInstance1.AssociatedRanList = []string{"test1", "test2", "test3"}
-       e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
+       e2tInstance2 := entities.NewE2TInstance(E2TAddress2, PodName)
        e2tInstance2.State = entities.ToBeDeleted
        e2tInstance2.AssociatedRanList = []string{"test4", "test5", "test6", "test7"}
 
@@ -278,9 +284,9 @@ func TestSelectE2TInstancesNoActiveE2TInstance(t *testing.T) {
 func TestSelectE2TInstancesSuccess(t *testing.T) {
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
        addresses := []string{E2TAddress, E2TAddress2}
-       e2tInstance1 := entities.NewE2TInstance(E2TAddress)
+       e2tInstance1 := entities.NewE2TInstance(E2TAddress, PodName)
        e2tInstance1.AssociatedRanList = []string{"test1", "test2", "test3"}
-       e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
+       e2tInstance2 := entities.NewE2TInstance(E2TAddress2, PodName)
        e2tInstance2.AssociatedRanList = []string{"test4", "test5", "test6", "test7"}
 
        rnibReaderMock.On("GetE2TAddresses").Return(addresses, nil)
@@ -293,37 +299,38 @@ func TestSelectE2TInstancesSuccess(t *testing.T) {
 }
 
 func TestActivateE2TInstanceSuccess(t *testing.T) {
-       _, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+       rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 
-       e2tInstance1 := entities.NewE2TInstance(E2TAddress)
-       e2tInstance1.State = entities.RoutingManagerFailure
+       e2tInstance1 := entities.NewE2TInstance(E2TAddress, PodName)
+       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)
 
-       rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
-
-       err := e2tInstancesManager.ActivateE2TInstance(e2tInstance1)
+       err := e2tInstancesManager.SetE2tInstanceState(E2TAddress, entities.ToBeDeleted, entities.Active)
        assert.Nil(t, err)
        assert.Equal(t, entities.Active, e2tInstance1.State)
        rnibWriterMock.AssertExpectations(t)
 }
 
 func TestActivateE2TInstance_RnibError(t *testing.T) {
-       _, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
-
-       e2tInstance1 := entities.NewE2TInstance(E2TAddress)
-       e2tInstance1.State = entities.RoutingManagerFailure
-       e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"}
+       rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 
-       rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(errors.New("Error")))
+       var e2tInstance1 *entities.E2TInstance
+       rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, common.NewInternalError(errors.New("for test")))
 
-       err := e2tInstancesManager.ActivateE2TInstance(e2tInstance1)
+       err := e2tInstancesManager.SetE2tInstanceState(E2TAddress, entities.ToBeDeleted, entities.Active)
        assert.NotNil(t, err)
+       rnibWriterMock.AssertExpectations(t)
 }
 
 func TestActivateE2TInstance_NoInstance(t *testing.T) {
-       _, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+       rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+       var e2tInstance1 *entities.E2TInstance
+       rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, e2managererrors.NewResourceNotFoundError())
 
-       err := e2tInstancesManager.ActivateE2TInstance(nil)
+       err := e2tInstancesManager.SetE2tInstanceState(E2TAddress, entities.ToBeDeleted, entities.Active)
 
        assert.NotNil(t, err)
        rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
@@ -333,7 +340,7 @@ func TestResetKeepAliveTimestampGetInternalFailure(t *testing.T) {
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 
        address := "10.10.2.15:9800"
-       e2tInstance := entities.NewE2TInstance(address)
+       e2tInstance := entities.NewE2TInstance(address, PodName)
        rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, common.NewInternalError(errors.New("Error")))
        rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
 
@@ -346,7 +353,7 @@ func TestAResetKeepAliveTimestampSaveInternalFailure(t *testing.T) {
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 
        address := "10.10.2.15:9800"
-       e2tInstance := entities.NewE2TInstance(address)
+       e2tInstance := entities.NewE2TInstance(address, PodName)
        rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
        rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(errors.New("Error")))
 
@@ -358,7 +365,7 @@ func TestResetKeepAliveTimestampSuccess(t *testing.T) {
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 
        address := "10.10.2.15:9800"
-       e2tInstance := entities.NewE2TInstance(address)
+       e2tInstance := entities.NewE2TInstance(address, PodName)
        rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
        rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
 
@@ -372,7 +379,7 @@ func TestResetKeepAliveTimestampToBeDeleted(t *testing.T) {
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 
        address := "10.10.2.15:9800"
-       e2tInstance := entities.NewE2TInstance(address)
+       e2tInstance := entities.NewE2TInstance(address, PodName)
        e2tInstance.State = entities.ToBeDeleted
        rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
 
@@ -382,27 +389,6 @@ func TestResetKeepAliveTimestampToBeDeleted(t *testing.T) {
        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 TestRemoveE2TInstance(t *testing.T) {
-       _, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
-       e2tInstance1 := entities.NewE2TInstance(E2TAddress)
-       err := e2tInstancesManager.RemoveE2TInstance(e2tInstance1)
-       assert.Nil(t, err)
-}
-
 func TestResetKeepAliveTimestampsForAllE2TInstancesGetE2TInstancesFailure(t *testing.T) {
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
        rnibReaderMock.On("GetE2TAddresses").Return([]string{}, common.NewInternalError(errors.New("Error")))
@@ -421,10 +407,10 @@ func TestResetKeepAliveTimestampsForAllE2TInstancesNoActiveInstances(t *testing.
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
        e2tAddresses := []string{E2TAddress, E2TAddress2}
        rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
-       e2tInstance1 := entities.NewE2TInstance(E2TAddress)
+       e2tInstance1 := entities.NewE2TInstance(E2TAddress, PodName)
        e2tInstance1.State = entities.ToBeDeleted
-       e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
-       e2tInstance2.State = entities.RoutingManagerFailure
+       e2tInstance2 := entities.NewE2TInstance(E2TAddress2, PodName)
+       e2tInstance2.State = entities.ToBeDeleted
        rnibReaderMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
        e2tInstancesManager.ResetKeepAliveTimestampsForAllE2TInstances()
        rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
@@ -434,9 +420,9 @@ func TestResetKeepAliveTimestampsForAllE2TInstancesOneActiveInstance(t *testing.
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
        e2tAddresses := []string{E2TAddress, E2TAddress2}
        rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
-       e2tInstance1 := entities.NewE2TInstance(E2TAddress)
+       e2tInstance1 := entities.NewE2TInstance(E2TAddress, PodName)
        e2tInstance1.State = entities.Active
-       e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
+       e2tInstance2 := entities.NewE2TInstance(E2TAddress2, PodName)
        e2tInstance2.State = entities.ToBeDeleted
        rnibReaderMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
        rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
@@ -448,12 +434,121 @@ func TestResetKeepAliveTimestampsForAllE2TInstancesSaveE2TInstanceFailure(t *tes
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
        e2tAddresses := []string{E2TAddress, E2TAddress2}
        rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
-       e2tInstance1 := entities.NewE2TInstance(E2TAddress)
+       e2tInstance1 := entities.NewE2TInstance(E2TAddress, PodName)
        e2tInstance1.State = entities.Active
-       e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
+       e2tInstance2 := entities.NewE2TInstance(E2TAddress2, PodName)
        e2tInstance2.State = entities.ToBeDeleted
        rnibReaderMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
        rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(errors.New("Error")))
        e2tInstancesManager.ResetKeepAliveTimestampsForAllE2TInstances()
        rnibWriterMock.AssertNumberOfCalls(t, "SaveE2TInstance",1)
 }
+
+func TestRemoveE2TInstanceSuccess(t *testing.T) {
+       rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+       rnibWriterMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
+       e2tAddresses := []string{E2TAddress, E2TAddress2}
+       rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
+       e2tAddressesNew := []string{E2TAddress2}
+       rnibWriterMock.On("SaveE2TAddresses", e2tAddressesNew).Return(nil)
+
+       err := e2tInstancesManager.RemoveE2TInstance(E2TAddress)
+       assert.Nil(t, err)
+       rnibReaderMock.AssertExpectations(t)
+       rnibWriterMock.AssertExpectations(t)
+}
+
+func TestRemoveE2TInstanceRnibErrorInRemoveInstance(t *testing.T) {
+       rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+       rnibWriterMock.On("RemoveE2TInstance", E2TAddress).Return(e2managererrors.NewRnibDbError())
+
+       err := e2tInstancesManager.RemoveE2TInstance(E2TAddress)
+       assert.NotNil(t, err)
+       assert.IsType(t, e2managererrors.NewRnibDbError(), err)
+       rnibReaderMock.AssertExpectations(t)
+       rnibWriterMock.AssertExpectations(t)
+}
+
+func TestRemoveE2TInstanceRnibErrorInGetAddresses(t *testing.T) {
+       rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+       rnibWriterMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
+       var e2tAddresses []string
+       rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, e2managererrors.NewRnibDbError())
+
+       err := e2tInstancesManager.RemoveE2TInstance(E2TAddress)
+       assert.NotNil(t, err)
+       assert.IsType(t, e2managererrors.NewRnibDbError(), err)
+       rnibReaderMock.AssertExpectations(t)
+       rnibWriterMock.AssertExpectations(t)
+}
+
+func TestRemoveE2TInstanceRnibErrorInSaveAddresses(t *testing.T) {
+       rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+       rnibWriterMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
+       e2tAddresses := []string{E2TAddress, E2TAddress2}
+       rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
+       e2tAddressesNew := []string{E2TAddress2}
+       rnibWriterMock.On("SaveE2TAddresses", e2tAddressesNew).Return(e2managererrors.NewRnibDbError())
+
+       err := e2tInstancesManager.RemoveE2TInstance(E2TAddress)
+       assert.NotNil(t, err)
+       assert.IsType(t, e2managererrors.NewRnibDbError(), err)
+       rnibReaderMock.AssertExpectations(t)
+       rnibWriterMock.AssertExpectations(t)
+}
+
+func TestSetE2tInstanceStateCurrentStateHasChanged(t *testing.T) {
+       rnibReaderMock, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+       e2tInstance := entities.NewE2TInstance(E2TAddress, PodName)
+       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, PodName)
+       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, PodName)
+       e2tInstance1.AssociatedRanList = []string{"test1", "test2", "test3"}
+       e2tInstance2 := entities.NewE2TInstance(E2TAddress2, PodName)
+       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)
+}