[RICPLT-2585] add UTs coverage

Change-Id: I969d2102376a49561637c0e697eb3a2410cc1972
Signed-off-by: Amichai <amichai.sichel@intl.att.com>

diff --git a/E2Manager/handlers/rmrmsghandlers/e2_term_init_notification_handler_test.go b/E2Manager/handlers/rmrmsghandlers/e2_term_init_notification_handler_test.go
index d476b1f..5101eae 100644 (file)
--- a/E2Manager/handlers/rmrmsghandlers/e2_term_init_notification_handler_test.go
+++ b/E2Manager/handlers/rmrmsghandlers/e2_term_init_notification_handler_test.go
@@ -58,6 +58,15 @@ func initRanLostConnectionTest(t *testing.T) (*logger.Logger, E2TermInitNotifica
        return logger, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock
 }
 
+func TestE2TermInitUnmarshalPayloadFailure(t *testing.T) {
+       _, handler, _, _, _, e2tInstancesManagerMock := initRanLostConnectionTest(t)
+       notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte("asd")}
+       handler.Handle(notificationRequest)
+       e2tInstancesManagerMock.AssertNotCalled(t, "GetE2TInstance")
+       e2tInstancesManagerMock.AssertNotCalled(t, "AddE2TInstance")
+}
+
+
 func TestE2TermInitGetE2TInstanceFailure(t *testing.T) {
        _, handler, _, _, _, e2tInstancesManagerMock := initRanLostConnectionTest(t)
        var e2tInstance *entities.E2TInstance

diff --git a/E2Manager/managers/e2t_instances_manager_test.go b/E2Manager/managers/e2t_instances_manager_test.go
index 4928de0..029d506 100644 (file)
--- a/E2Manager/managers/e2t_instances_manager_test.go
+++ b/E2Manager/managers/e2t_instances_manager_test.go
@@ -5,6 +5,7 @@ import (
        "e2mgr/logger"
        "e2mgr/mocks"
        "e2mgr/services"
+       "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"
@@ -88,3 +89,278 @@ func TestAddNewE2TInstanceSaveE2TInfoListFailure(t *testing.T) {
        err := e2tInstancesManager.AddE2TInstance(E2TAddress)
        assert.NotNil(t, err)
 }
+
+func TestGetE2TInstanceSuccess(t *testing.T) {
+       rnibReaderMock, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
+       address := "10.10.2.15:9800"
+       e2tInstance := entities.NewE2TInstance(address)
+       rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
+       res, err := e2tInstancesManager.GetE2TInstance(address)
+       assert.Nil(t, err)
+       assert.Equal(t, e2tInstance, res)
+}
+
+func TestGetE2TInstanceFailure(t *testing.T) {
+       rnibReaderMock, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
+       address := "10.10.2.15:9800"
+       var e2tInstance *entities.E2TInstance
+       rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, common.NewInternalError(fmt.Errorf("for test")))
+       res, err := e2tInstancesManager.GetE2TInstance(address)
+       assert.NotNil(t, err)
+       assert.Nil(t, res)
+}
+
+func TestAssociateRanSuccess(t *testing.T) {
+       rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+       address1 := "10.10.2.15:9800"
+       e2tInfo1 := entities.NewE2TInstanceInfo(address1)
+       e2tInfo1.AssociatedRanCount = 0;
+       address2 := "10.10.2.15:9801"
+       e2tInfo2 := entities.NewE2TInstanceInfo(address2)
+       e2tInfo2.AssociatedRanCount = 1;
+       e2tInfoList := []*entities.E2TInstanceInfo{e2tInfo1, e2tInfo2}
+       rnibReaderMock.On("GetE2TInfoList").Return(e2tInfoList, nil)
+
+       e2tInfo3 := entities.NewE2TInstanceInfo(address1)
+       e2tInfo3.AssociatedRanCount = 1;
+       e2tInfoList2 := []*entities.E2TInstanceInfo{e2tInfo3, e2tInfo2}
+       rnibWriterMock.On("SaveE2TInfoList", e2tInfoList2).Return(nil)
+
+       e2tInstance1  := entities.NewE2TInstance(address1)
+       rnibReaderMock.On("GetE2TInstance", address1).Return(e2tInstance1, nil)
+       rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
+
+       err := e2tInstancesManager.AssociateRan("test1", address1)
+       assert.Nil(t, err)
+       rnibReaderMock.AssertExpectations(t)
+       rnibWriterMock.AssertExpectations(t)
+}
+
+func TestAssociateRanGetListFailure(t *testing.T) {
+       rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+       address1 := "10.10.2.15:9800"
+
+       var e2tInfoList []*entities.E2TInstanceInfo
+       rnibReaderMock.On("GetE2TInfoList").Return(e2tInfoList, common.NewInternalError(fmt.Errorf("for test")))
+
+       err := e2tInstancesManager.AssociateRan("test1", address1)
+       assert.NotNil(t, err)
+       rnibWriterMock.AssertNotCalled(t, "SaveE2TInfoList")
+       rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
+       rnibReaderMock.AssertNotCalled(t, "GetE2TInstance")
+}
+
+func TestAssociateRanSaveListFailure(t *testing.T) {
+       rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+       address1 := "10.10.2.15:9800"
+       e2tInfo1 := entities.NewE2TInstanceInfo(address1)
+       e2tInfo1.AssociatedRanCount = 0;
+       address2 := "10.10.2.15:9801"
+       e2tInfo2 := entities.NewE2TInstanceInfo(address2)
+       e2tInfo2.AssociatedRanCount = 1;
+       e2tInfoList := []*entities.E2TInstanceInfo{e2tInfo1, e2tInfo2}
+       rnibReaderMock.On("GetE2TInfoList").Return(e2tInfoList, nil)
+
+       rnibWriterMock.On("SaveE2TInfoList", e2tInfoList).Return(common.NewInternalError(fmt.Errorf("for test")))
+
+       err := e2tInstancesManager.AssociateRan("test1", address1)
+       assert.NotNil(t, err)
+       rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
+       rnibReaderMock.AssertNotCalled(t, "GetE2TInstance")
+}
+
+func TestAssociateRanGetInstanceFailure(t *testing.T) {
+       rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+       address1 := "10.10.2.15:9800"
+       e2tInfo1 := entities.NewE2TInstanceInfo(address1)
+       e2tInfo1.AssociatedRanCount = 0;
+       address2 := "10.10.2.15:9801"
+       e2tInfo2 := entities.NewE2TInstanceInfo(address2)
+       e2tInfo2.AssociatedRanCount = 1;
+       e2tInfoList := []*entities.E2TInstanceInfo{e2tInfo1, e2tInfo2}
+       rnibReaderMock.On("GetE2TInfoList").Return(e2tInfoList, nil)
+       rnibWriterMock.On("SaveE2TInfoList", e2tInfoList).Return(nil)
+
+       var e2tInstance1 *entities.E2TInstance
+       rnibReaderMock.On("GetE2TInstance", address1).Return(e2tInstance1, common.NewInternalError(fmt.Errorf("for test")))
+
+       err := e2tInstancesManager.AssociateRan("test1", address1)
+       assert.NotNil(t, err)
+       rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
+}
+
+func TestAssociateRanSaveInstanceFailure(t *testing.T) {
+       rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+       address1 := "10.10.2.15:9800"
+       e2tInfo1 := entities.NewE2TInstanceInfo(address1)
+       e2tInfo1.AssociatedRanCount = 0;
+       address2 := "10.10.2.15:9801"
+       e2tInfo2 := entities.NewE2TInstanceInfo(address2)
+       e2tInfo2.AssociatedRanCount = 1;
+       e2tInfoList := []*entities.E2TInstanceInfo{e2tInfo1, e2tInfo2}
+       rnibReaderMock.On("GetE2TInfoList").Return(e2tInfoList, nil)
+
+       e2tInfo3 := entities.NewE2TInstanceInfo(address1)
+       e2tInfo3.AssociatedRanCount = 1;
+       e2tInfoList2 := []*entities.E2TInstanceInfo{e2tInfo3, e2tInfo2}
+       rnibWriterMock.On("SaveE2TInfoList", e2tInfoList2).Return(nil)
+
+       e2tInstance1  := entities.NewE2TInstance(address1)
+       rnibReaderMock.On("GetE2TInstance", address1).Return(e2tInstance1, nil)
+       rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(fmt.Errorf("for test")))
+
+       err := e2tInstancesManager.AssociateRan("test1", address1)
+       assert.NotNil(t, err)
+       rnibReaderMock.AssertExpectations(t)
+       rnibWriterMock.AssertExpectations(t)
+}
+
+func TestDeassociateRanSuccess(t *testing.T) {
+       rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+       address1 := "10.10.2.15:9800"
+       e2tInfo1 := entities.NewE2TInstanceInfo(address1)
+       e2tInfo1.AssociatedRanCount = 1;
+       address2 := "10.10.2.15:9801"
+       e2tInfo2 := entities.NewE2TInstanceInfo(address2)
+       e2tInfo2.AssociatedRanCount = 0;
+       e2tInfoList := []*entities.E2TInstanceInfo{e2tInfo1, e2tInfo2}
+       rnibReaderMock.On("GetE2TInfoList").Return(e2tInfoList, nil)
+
+       e2tInfo3 := entities.NewE2TInstanceInfo(address1)
+       e2tInfo3.AssociatedRanCount = 0;
+       e2tInfoList2 := []*entities.E2TInstanceInfo{e2tInfo3, e2tInfo2}
+       rnibWriterMock.On("SaveE2TInfoList", e2tInfoList2).Return(nil)
+
+       e2tInstance1  := entities.NewE2TInstance(address1)
+       e2tInstance1.AssociatedRanList = append(e2tInstance1.AssociatedRanList, "test0", "test1")
+       rnibReaderMock.On("GetE2TInstance", address1).Return(e2tInstance1, nil)
+       rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
+
+       err := e2tInstancesManager.DeassociateRan("test1", address1)
+       assert.Nil(t, err)
+       rnibReaderMock.AssertExpectations(t)
+       rnibWriterMock.AssertExpectations(t)
+}
+
+func TestDeassociateRanNoInstanceFound(t *testing.T) {
+       rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+       address1 := "10.10.2.15:9800"
+       e2tInfoList := []*entities.E2TInstanceInfo{}
+       rnibReaderMock.On("GetE2TInfoList").Return(e2tInfoList, nil)
+
+       err := e2tInstancesManager.DeassociateRan("test1", address1)
+       assert.Nil(t, err)
+       rnibWriterMock.AssertNotCalled(t, "SaveE2TInfoList")
+       rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
+       rnibReaderMock.AssertNotCalled(t, "GetE2TInstance")
+}
+
+func TestDeassociateRanGetListFailure(t *testing.T) {
+       rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+       address1 := "10.10.2.15:9800"
+
+       var e2tInfoList []*entities.E2TInstanceInfo
+       rnibReaderMock.On("GetE2TInfoList").Return(e2tInfoList, common.NewInternalError(fmt.Errorf("for test")))
+
+       err := e2tInstancesManager.DeassociateRan("test1", address1)
+       assert.NotNil(t, err)
+       rnibWriterMock.AssertNotCalled(t, "SaveE2TInfoList")
+       rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
+       rnibReaderMock.AssertNotCalled(t, "GetE2TInstance")
+}
+
+func TestDeassociateRanSaveListFailure(t *testing.T) {
+       rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+       address1 := "10.10.2.15:9800"
+       e2tInfo1 := entities.NewE2TInstanceInfo(address1)
+       e2tInfo1.AssociatedRanCount = 0;
+       address2 := "10.10.2.15:9801"
+       e2tInfo2 := entities.NewE2TInstanceInfo(address2)
+       e2tInfo2.AssociatedRanCount = 1;
+       e2tInfoList := []*entities.E2TInstanceInfo{e2tInfo1, e2tInfo2}
+       rnibReaderMock.On("GetE2TInfoList").Return(e2tInfoList, nil)
+
+       rnibWriterMock.On("SaveE2TInfoList", e2tInfoList).Return(common.NewInternalError(fmt.Errorf("for test")))
+
+       err := e2tInstancesManager.DeassociateRan("test1", address1)
+       assert.NotNil(t, err)
+       rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
+       rnibReaderMock.AssertNotCalled(t, "GetE2TInstance")
+}
+
+func TestDeassociateRanGetInstanceFailure(t *testing.T) {
+       rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+       address1 := "10.10.2.15:9800"
+       e2tInfo1 := entities.NewE2TInstanceInfo(address1)
+       e2tInfo1.AssociatedRanCount = 0;
+       address2 := "10.10.2.15:9801"
+       e2tInfo2 := entities.NewE2TInstanceInfo(address2)
+       e2tInfo2.AssociatedRanCount = 1;
+       e2tInfoList := []*entities.E2TInstanceInfo{e2tInfo1, e2tInfo2}
+       rnibReaderMock.On("GetE2TInfoList").Return(e2tInfoList, nil)
+       rnibWriterMock.On("SaveE2TInfoList", e2tInfoList).Return(nil)
+
+       var e2tInstance1 *entities.E2TInstance
+       rnibReaderMock.On("GetE2TInstance", address1).Return(e2tInstance1, common.NewInternalError(fmt.Errorf("for test")))
+
+       err := e2tInstancesManager.DeassociateRan("test1", address1)
+       assert.NotNil(t, err)
+       rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
+}
+
+func TestDeassociateRanSaveInstanceFailure(t *testing.T) {
+       rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+       address1 := "10.10.2.15:9800"
+       e2tInfo1 := entities.NewE2TInstanceInfo(address1)
+       e2tInfo1.AssociatedRanCount = 1;
+       address2 := "10.10.2.15:9801"
+       e2tInfo2 := entities.NewE2TInstanceInfo(address2)
+       e2tInfo2.AssociatedRanCount = 0;
+       e2tInfoList := []*entities.E2TInstanceInfo{e2tInfo1, e2tInfo2}
+       rnibReaderMock.On("GetE2TInfoList").Return(e2tInfoList, nil)
+
+       e2tInfo3 := entities.NewE2TInstanceInfo(address1)
+       e2tInfo3.AssociatedRanCount = 0;
+       e2tInfoList2 := []*entities.E2TInstanceInfo{e2tInfo3, e2tInfo2}
+       rnibWriterMock.On("SaveE2TInfoList", e2tInfoList2).Return(nil)
+
+       e2tInstance1  := entities.NewE2TInstance(address1)
+       rnibReaderMock.On("GetE2TInstance", address1).Return(e2tInstance1, nil)
+       rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(fmt.Errorf("for test")))
+
+       err := e2tInstancesManager.DeassociateRan("test1", address1)
+       assert.NotNil(t, err)
+       rnibReaderMock.AssertExpectations(t)
+       rnibWriterMock.AssertExpectations(t)
+}
+
+
+func TestRemoveE2TInstance(t *testing.T) {
+       _, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
+       address1 := "10.10.2.15:9800"
+       e2tInstance1  := entities.NewE2TInstance(address1)
+       err := e2tInstancesManager.RemoveE2TInstance(e2tInstance1)
+       assert.Nil(t, err)
+}
+
+func TestSelectE2TInstance(t *testing.T) {
+       _, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
+       address1 := "10.10.2.15:9800"
+       e2tInstance1  := entities.NewE2TInstance(address1)
+       addr, err := e2tInstancesManager.SelectE2TInstance(e2tInstance1)
+       assert.Nil(t, err)
+       assert.Equal(t, "", addr)
+}
+
+

diff --git a/E2Manager/rNibWriter/rNibWriter_test.go b/E2Manager/rNibWriter/rNibWriter_test.go
index 7f0b550..d8bea50 100644 (file)
--- a/E2Manager/rNibWriter/rNibWriter_test.go
+++ b/E2Manager/rNibWriter/rNibWriter_test.go
@@ -19,6 +19,7 @@ package rNibWriter
 
 import (
        "e2mgr/mocks"
+       "encoding/json"
        "errors"
        "fmt"
        "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
@@ -531,3 +532,116 @@ func TestGetRNibWriter(t *testing.T) {
 //                     t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationInteg - Failed to save RanLoadInformation entity. Error: %v", err)
 //             }
 //}
+
+func TestSaveE2TInstanceSuccess(t *testing.T) {
+       address := "10.10.2.15:9800"
+       loadKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
+
+       if validationErr != nil {
+               t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
+       }
+
+       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+
+       e2tInstance := generateE2tInstance(address)
+       data, err := json.Marshal(e2tInstance)
+
+       if err != nil {
+               t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSuccess - Failed to marshal E2tInstance entity. Error: %v", err)
+       }
+
+       var e error
+       var setExpected []interface{}
+       setExpected = append(setExpected, loadKey, data)
+       sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
+
+       rNibErr := w.SaveE2TInstance(e2tInstance)
+       assert.Nil(t, rNibErr)
+}
+
+func TestSaveE2TInstanceNullE2tInstanceFailure(t *testing.T) {
+       w, _ := initSdlInstanceMock(namespace)
+       var address string
+       e2tInstance := entities.NewE2TInstance(address)
+       err := w.SaveE2TInstance(e2tInstance)
+       assert.NotNil(t, err)
+       assert.IsType(t, &common.ValidationError{}, err)
+}
+
+func TestSaveE2TInstanceSdlFailure(t *testing.T) {
+       address := "10.10.2.15:9800"
+       loadKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
+
+       if validationErr != nil {
+               t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSdlFailure - Failed to build E2T Instance key. Error: %v", validationErr)
+       }
+
+       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+
+       e2tInstance := generateE2tInstance(address)
+       data, err := json.Marshal(e2tInstance)
+
+       if err != nil {
+               t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSdlFailure - Failed to marshal E2tInstance entity. Error: %v", err)
+       }
+
+       expectedErr := errors.New("expected error")
+       var setExpected []interface{}
+       setExpected = append(setExpected, loadKey, data)
+       sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
+
+       rNibErr := w.SaveE2TInstance(e2tInstance)
+       assert.NotNil(t, rNibErr)
+       assert.IsType(t, &common.InternalError{}, rNibErr)
+}
+
+func generateE2tInstance(address string) *entities.E2TInstance {
+       e2tInstance := entities.NewE2TInstance(address)
+
+       e2tInstance.AssociatedRanList = []string{"test1", "test2"}
+
+       return e2tInstance
+}
+
+func TestSaveE2TInfoListSuccess(t *testing.T) {
+       address := "10.10.2.15:9800"
+       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+
+       e2tInfo := entities.NewE2TInstanceInfo(address)
+       e2tInfoList := []*entities.E2TInstanceInfo{e2tInfo}
+       data, err := json.Marshal(e2tInfoList)
+
+       if err != nil {
+               t.Errorf("#rNibWriter_test.TestSaveE2TInfoListSuccess - Failed to marshal E2TInfoList. Error: %v", err)
+       }
+
+       var e error
+       var setExpected []interface{}
+       setExpected = append(setExpected, E2TInfoListKey, data)
+       sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
+
+       rNibErr := w.SaveE2TInfoList(e2tInfoList)
+       assert.Nil(t, rNibErr)
+}
+
+func TestSaveE2TInfoListSdlFailure(t *testing.T) {
+       address := "10.10.2.15:9800"
+       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+
+       e2tInfo := entities.NewE2TInstanceInfo(address)
+       e2tInfoList := []*entities.E2TInstanceInfo{e2tInfo}
+       data, err := json.Marshal(e2tInfoList)
+
+       if err != nil {
+               t.Errorf("#rNibWriter_test.TestSaveE2TInfoListSdlFailure - Failed to marshal E2TInfoList. Error: %v", err)
+       }
+
+       expectedErr := errors.New("expected error")
+       var setExpected []interface{}
+       setExpected = append(setExpected, E2TInfoListKey, data)
+       sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
+
+       rNibErr := w.SaveE2TInfoList(e2tInfoList)
+       assert.NotNil(t, rNibErr)
+       assert.IsType(t, &common.InternalError{}, rNibErr)
+}
\ No newline at end of file

diff --git a/E2Manager/services/rnib_data_service_test.go b/E2Manager/services/rnib_data_service_test.go
index 0202292..2ba4116 100644 (file)
--- a/E2Manager/services/rnib_data_service_test.go
+++ b/E2Manager/services/rnib_data_service_test.go
@@ -268,3 +268,44 @@ func TestPingRnibOkOtherError(t *testing.T) {
 //     assert.True(t, strings.Contains(err.Error(),"connection failure", ))
 //     assert.Equal(t, nodeIds, res)
 //}
+
+func TestGetE2TInstanceConnFailure(t *testing.T) {
+       rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
+
+       address := "10.10.5.20:3200"
+       var e2tInstance *entities.E2TInstance = nil
+       mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
+       readerMock.On("GetE2TInstance", address).Return(e2tInstance, mockErr)
+
+       res, err := rnibDataService.GetE2TInstance(address)
+       readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 3)
+       assert.Nil(t, res)
+       assert.NotNil(t, err)
+}
+
+func TestGetE2TInstanceOkNoError(t *testing.T) {
+       rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
+
+       address := "10.10.5.20:3200"
+       e2tInstance := &entities.E2TInstance{}
+       readerMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
+
+       res, err := rnibDataService.GetE2TInstance(address)
+       readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 1)
+       assert.Nil(t, err)
+       assert.Equal(t, e2tInstance, res)
+}
+
+func TestGetE2TInstanceOkOtherError(t *testing.T) {
+       rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
+
+       address := "10.10.5.20:3200"
+       var e2tInstance *entities.E2TInstance = nil
+       mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
+       readerMock.On("GetE2TInstance", address).Return(e2tInstance, mockErr)
+
+       res, err := rnibDataService.GetE2TInstance(address)
+       readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 1)
+       assert.Nil(t, res)
+       assert.NotNil(t, err)
+}