E2Manager/services/rnib_data_service_test.go

   1 package services
   2
   3 import (
   4         "e2mgr/configuration"
   5         "e2mgr/logger"
   6         "e2mgr/mocks"
   7         "e2mgr/rNibWriter"
   8         "fmt"
   9         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  10         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  11         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
  12         "github.com/stretchr/testify/assert"
  13         "net"
  14         "strings"
  15         "testing"
  16 )
  17
  18 func setupTest(t *testing.T) (*rNibDataService, *mocks.RnibReaderMock, *mocks.RnibWriterMock) {
  19         logger, err := logger.InitLogger(logger.DebugLevel)
  20         if err != nil {
  21                 t.Errorf("#... - failed to initialize logger, error: %s", err)
  22         }
  23
  24         config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
  25
  26         readerMock := &mocks.RnibReaderMock{}
  27         rnibReaderProvider := func() reader.RNibReader {
  28                 return readerMock
  29         }
  30
  31         writerMock := &mocks.RnibWriterMock{}
  32         rnibWriterProvider := func() rNibWriter.RNibWriter {
  33                 return writerMock
  34         }
  35
  36         rnibDataService := NewRnibDataService(logger, config, rnibReaderProvider, rnibWriterProvider)
  37         assert.NotNil(t, rnibDataService)
  38
  39         return rnibDataService, readerMock, writerMock
  40 }
  41
  42 func TestSuccessfulSaveNodeb(t *testing.T) {
  43         rnibDataService, _, writerMock := setupTest(t)
  44
  45         nodebInfo := &entities.NodebInfo{}
  46         nbIdentity := &entities.NbIdentity{}
  47         writerMock.On("SaveNodeb", nbIdentity, nodebInfo).Return(nil)
  48
  49         rnibDataService.SaveNodeb(nbIdentity, nodebInfo)
  50         writerMock.AssertNumberOfCalls(t, "SaveNodeb", 1)
  51 }
  52
  53 func TestConnFailureSaveNodeb(t *testing.T) {
  54         rnibDataService, _, writerMock := setupTest(t)
  55
  56         nodebInfo := &entities.NodebInfo{}
  57         nbIdentity := &entities.NbIdentity{}
  58         mockErr := common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
  59         writerMock.On("SaveNodeb", nbIdentity, nodebInfo).Return(mockErr)
  60
  61         rnibDataService.SaveNodeb(nbIdentity, nodebInfo)
  62         writerMock.AssertNumberOfCalls(t, "SaveNodeb", 3)
  63 }
  64
  65 func TestNonConnFailureSaveNodeb(t *testing.T) {
  66         rnibDataService, _, writerMock := setupTest(t)
  67
  68         nodebInfo := &entities.NodebInfo{}
  69         nbIdentity := &entities.NbIdentity{}
  70         mockErr := common.InternalError{Err: fmt.Errorf("non connection failure")}
  71         writerMock.On("SaveNodeb", nbIdentity, nodebInfo).Return(mockErr)
  72
  73         rnibDataService.SaveNodeb(nbIdentity, nodebInfo)
  74         writerMock.AssertNumberOfCalls(t, "SaveNodeb", 1)
  75 }
  76
  77 func TestSuccessfulUpdateNodebInfo(t *testing.T) {
  78         rnibDataService, _, writerMock := setupTest(t)
  79
  80         nodebInfo := &entities.NodebInfo{}
  81         writerMock.On("UpdateNodebInfo", nodebInfo).Return(nil)
  82
  83         rnibDataService.UpdateNodebInfo(nodebInfo)
  84         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
  85 }
  86
  87 func TestConnFailureUpdateNodebInfo(t *testing.T) {
  88         rnibDataService, _, writerMock := setupTest(t)
  89
  90         nodebInfo := &entities.NodebInfo{}
  91         mockErr := common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
  92         writerMock.On("UpdateNodebInfo", nodebInfo).Return(mockErr)
  93
  94         rnibDataService.UpdateNodebInfo(nodebInfo)
  95         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 3)
  96 }
  97
  98 func TestSuccessfulSaveRanLoadInformation(t *testing.T) {
  99         rnibDataService, _, writerMock := setupTest(t)
 100
 101         var ranName string = "abcd"
 102         ranLoadInformation := &entities.RanLoadInformation{}
 103         writerMock.On("SaveRanLoadInformation", ranName, ranLoadInformation).Return(nil)
 104
 105         rnibDataService.SaveRanLoadInformation(ranName, ranLoadInformation)
 106         writerMock.AssertNumberOfCalls(t, "SaveRanLoadInformation", 1)
 107 }
 108
 109 func TestConnFailureSaveRanLoadInformation(t *testing.T) {
 110         rnibDataService, _, writerMock := setupTest(t)
 111
 112         var ranName string = "abcd"
 113         ranLoadInformation := &entities.RanLoadInformation{}
 114         mockErr := common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 115         writerMock.On("SaveRanLoadInformation", ranName, ranLoadInformation).Return(mockErr)
 116
 117         rnibDataService.SaveRanLoadInformation(ranName, ranLoadInformation)
 118         writerMock.AssertNumberOfCalls(t, "SaveRanLoadInformation", 3)
 119 }
 120
 121 func TestSuccessfulGetNodeb(t *testing.T) {
 122         rnibDataService, readerMock, _ := setupTest(t)
 123
 124         invName := "abcd"
 125         nodebInfo := &entities.NodebInfo{}
 126         readerMock.On("GetNodeb", invName).Return(nodebInfo, nil)
 127
 128         res, err := rnibDataService.GetNodeb(invName)
 129         readerMock.AssertNumberOfCalls(t, "GetNodeb", 1)
 130         assert.Equal(t, nodebInfo, res)
 131         assert.Nil(t, err)
 132 }
 133
 134 func TestConnFailureGetNodeb(t *testing.T) {
 135         rnibDataService, readerMock, _ := setupTest(t)
 136
 137         invName := "abcd"
 138         var nodeb *entities.NodebInfo = nil
 139         mockErr := common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 140         readerMock.On("GetNodeb", invName).Return(nodeb, mockErr)
 141
 142         res, err := rnibDataService.GetNodeb(invName)
 143         readerMock.AssertNumberOfCalls(t, "GetNodeb", 3)
 144         assert.True(t, strings.Contains(err.Error(), "connection error", ))
 145         assert.Equal(t, nodeb, res)
 146 }
 147
 148 func TestSuccessfulGetNodebIdList(t *testing.T) {
 149         rnibDataService, readerMock, _ := setupTest(t)
 150
 151         nodeIds := []*entities.NbIdentity{}
 152         readerMock.On("GetListNodebIds").Return(nodeIds, nil)
 153
 154         res, err := rnibDataService.GetListNodebIds()
 155         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 1)
 156         assert.Equal(t, nodeIds, res)
 157         assert.Nil(t, err)
 158 }
 159
 160 func TestConnFailureGetNodebIdList(t *testing.T) {
 161         rnibDataService, readerMock, _ := setupTest(t)
 162
 163         var nodeIds []*entities.NbIdentity = nil
 164         mockErr := common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 165         readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
 166
 167         res, err := rnibDataService.GetListNodebIds()
 168         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 3)
 169         assert.True(t, strings.Contains(err.Error(), "connection error", ))
 170         assert.Equal(t, nodeIds, res)
 171 }
 172
 173 //func TestConnFailureThenSuccessGetNodebIdList(t *testing.T) {
 174 //      rnibDataService, readerMock, _ := setupTest(t)
 175 //
 176 //      var nilNodeIds []*entities.NbIdentity = nil
 177 //      nodeIds := []*entities.NbIdentity{}
 178 //      mockErr := common.InternalError{Err: &net.OpError{Err:fmt.Errorf("connection error")}}
 179 //      //readerMock.On("GetListNodebIds").Return(nilNodeIds, mockErr)
 180 //      //readerMock.On("GetListNodebIds").Return(nodeIds, nil)
 181 //
 182 //      res, err := rnibDataService.GetListNodebIds()
 183 //      readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 2)
 184 //      assert.True(t, strings.Contains(err.Error(),"connection failure", ))
 185 //      assert.Equal(t, nodeIds, res)
 186 //}