E2Manager/services/rnib_data_service_test.go

   1 //
   2 // Copyright 2019 AT&T Intellectual Property
   3 // Copyright 2019 Nokia
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the "License");
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //      http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 package services
  19
  20 import (
  21         "e2mgr/configuration"
  22         "e2mgr/logger"
  23         "e2mgr/mocks"
  24         "e2mgr/rNibWriter"
  25         "fmt"
  26         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  27         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  28         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
  29         "github.com/stretchr/testify/assert"
  30         "net"
  31         "strings"
  32         "testing"
  33 )
  34
  35 func setupRnibDataServiceTest(t *testing.T) (*rNibDataService, *mocks.RnibReaderMock, *mocks.RnibWriterMock) {
  36         return setupRnibDataServiceTestWithMaxAttempts(t, 3)
  37 }
  38
  39 func setupRnibDataServiceTestWithMaxAttempts(t *testing.T, maxAttempts int) (*rNibDataService, *mocks.RnibReaderMock, *mocks.RnibWriterMock) {
  40         logger, err := logger.InitLogger(logger.DebugLevel)
  41         if err != nil {
  42                 t.Errorf("#... - failed to initialize logger, error: %s", err)
  43         }
  44
  45         config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: maxAttempts}
  46
  47         readerMock := &mocks.RnibReaderMock{}
  48         rnibReaderProvider := func() reader.RNibReader {
  49                 return readerMock
  50         }
  51
  52         writerMock := &mocks.RnibWriterMock{}
  53         rnibWriterProvider := func() rNibWriter.RNibWriter {
  54                 return writerMock
  55         }
  56
  57         rnibDataService := NewRnibDataService(logger, config, rnibReaderProvider, rnibWriterProvider)
  58         assert.NotNil(t, rnibDataService)
  59
  60         return rnibDataService, readerMock, writerMock
  61 }
  62
  63 func TestSuccessfulSaveNodeb(t *testing.T) {
  64         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
  65
  66         nodebInfo := &entities.NodebInfo{}
  67         nbIdentity := &entities.NbIdentity{}
  68         writerMock.On("SaveNodeb", nbIdentity, nodebInfo).Return(nil)
  69
  70         rnibDataService.SaveNodeb(nbIdentity, nodebInfo)
  71         writerMock.AssertNumberOfCalls(t, "SaveNodeb", 1)
  72 }
  73
  74 func TestConnFailureSaveNodeb(t *testing.T) {
  75         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
  76
  77         nodebInfo := &entities.NodebInfo{}
  78         nbIdentity := &entities.NbIdentity{}
  79         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
  80         writerMock.On("SaveNodeb", nbIdentity, nodebInfo).Return(mockErr)
  81
  82         rnibDataService.SaveNodeb(nbIdentity, nodebInfo)
  83         writerMock.AssertNumberOfCalls(t, "SaveNodeb", 3)
  84 }
  85
  86 func TestNonConnFailureSaveNodeb(t *testing.T) {
  87         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
  88
  89         nodebInfo := &entities.NodebInfo{}
  90         nbIdentity := &entities.NbIdentity{}
  91         mockErr := &common.InternalError{Err: fmt.Errorf("non connection failure")}
  92         writerMock.On("SaveNodeb", nbIdentity, nodebInfo).Return(mockErr)
  93
  94         rnibDataService.SaveNodeb(nbIdentity, nodebInfo)
  95         writerMock.AssertNumberOfCalls(t, "SaveNodeb", 1)
  96 }
  97
  98 func TestSuccessfulUpdateNodebInfo(t *testing.T) {
  99         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 100
 101         nodebInfo := &entities.NodebInfo{}
 102         writerMock.On("UpdateNodebInfo", nodebInfo).Return(nil)
 103
 104         rnibDataService.UpdateNodebInfo(nodebInfo)
 105         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
 106 }
 107
 108 func TestConnFailureUpdateNodebInfo(t *testing.T) {
 109         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 110
 111         nodebInfo := &entities.NodebInfo{}
 112         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 113         writerMock.On("UpdateNodebInfo", nodebInfo).Return(mockErr)
 114
 115         rnibDataService.UpdateNodebInfo(nodebInfo)
 116         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 3)
 117 }
 118
 119 func TestSuccessfulSaveRanLoadInformation(t *testing.T) {
 120         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 121
 122         var ranName string = "abcd"
 123         ranLoadInformation := &entities.RanLoadInformation{}
 124         writerMock.On("SaveRanLoadInformation", ranName, ranLoadInformation).Return(nil)
 125
 126         rnibDataService.SaveRanLoadInformation(ranName, ranLoadInformation)
 127         writerMock.AssertNumberOfCalls(t, "SaveRanLoadInformation", 1)
 128 }
 129
 130 func TestConnFailureSaveRanLoadInformation(t *testing.T) {
 131         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 132
 133         var ranName string = "abcd"
 134         ranLoadInformation := &entities.RanLoadInformation{}
 135         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 136         writerMock.On("SaveRanLoadInformation", ranName, ranLoadInformation).Return(mockErr)
 137
 138         rnibDataService.SaveRanLoadInformation(ranName, ranLoadInformation)
 139         writerMock.AssertNumberOfCalls(t, "SaveRanLoadInformation", 3)
 140 }
 141
 142 func TestSuccessfulGetNodeb(t *testing.T) {
 143         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 144
 145         invName := "abcd"
 146         nodebInfo := &entities.NodebInfo{}
 147         readerMock.On("GetNodeb", invName).Return(nodebInfo, nil)
 148
 149         res, err := rnibDataService.GetNodeb(invName)
 150         readerMock.AssertNumberOfCalls(t, "GetNodeb", 1)
 151         assert.Equal(t, nodebInfo, res)
 152         assert.Nil(t, err)
 153 }
 154
 155 func TestConnFailureGetNodeb(t *testing.T) {
 156         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 157
 158         invName := "abcd"
 159         var nodeb *entities.NodebInfo = nil
 160         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 161         readerMock.On("GetNodeb", invName).Return(nodeb, mockErr)
 162
 163         res, err := rnibDataService.GetNodeb(invName)
 164         readerMock.AssertNumberOfCalls(t, "GetNodeb", 3)
 165         assert.True(t, strings.Contains(err.Error(), "connection error", ))
 166         assert.Equal(t, nodeb, res)
 167 }
 168
 169 func TestSuccessfulGetNodebIdList(t *testing.T) {
 170         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 171
 172         nodeIds := []*entities.NbIdentity{}
 173         readerMock.On("GetListNodebIds").Return(nodeIds, nil)
 174
 175         res, err := rnibDataService.GetListNodebIds()
 176         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 1)
 177         assert.Equal(t, nodeIds, res)
 178         assert.Nil(t, err)
 179 }
 180
 181 func TestConnFailureGetNodebIdList(t *testing.T) {
 182         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 183
 184         var nodeIds []*entities.NbIdentity = nil
 185         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 186         readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
 187
 188         res, err := rnibDataService.GetListNodebIds()
 189         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 3)
 190         assert.True(t, strings.Contains(err.Error(), "connection error", ))
 191         assert.Equal(t, nodeIds, res)
 192 }
 193
 194 func TestConnFailureTwiceGetNodebIdList(t *testing.T) {
 195         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 196
 197         invName := "abcd"
 198         var nodeb *entities.NodebInfo = nil
 199         var nodeIds []*entities.NbIdentity = nil
 200         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 201         readerMock.On("GetNodeb", invName).Return(nodeb, mockErr)
 202         readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
 203
 204         res, err := rnibDataService.GetListNodebIds()
 205         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 3)
 206         assert.True(t, strings.Contains(err.Error(), "connection error", ))
 207         assert.Equal(t, nodeIds, res)
 208
 209         res2, err := rnibDataService.GetNodeb(invName)
 210         readerMock.AssertNumberOfCalls(t, "GetNodeb", 3)
 211         assert.True(t, strings.Contains(err.Error(), "connection error", ))
 212         assert.Equal(t, nodeb, res2)
 213 }
 214
 215 func TestConnFailureWithAnotherConfig(t *testing.T) {
 216         rnibDataService, readerMock, _ := setupRnibDataServiceTestWithMaxAttempts(t, 5)
 217
 218         var nodeIds []*entities.NbIdentity = nil
 219         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 220         readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
 221
 222         res, err := rnibDataService.GetListNodebIds()
 223         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 5)
 224         assert.True(t, strings.Contains(err.Error(), "connection error", ))
 225         assert.Equal(t, nodeIds, res)
 226 }
 227
 228 func TestPingRnibConnFailure(t *testing.T) {
 229         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 230
 231         var nodeIds []*entities.NbIdentity = nil
 232         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 233         readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
 234
 235         res := rnibDataService.PingRnib()
 236         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 3)
 237         assert.False(t, res)
 238 }
 239
 240 func TestPingRnibOkNoError(t *testing.T) {
 241         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 242
 243         var nodeIds []*entities.NbIdentity = nil
 244         readerMock.On("GetListNodebIds").Return(nodeIds, nil)
 245
 246         res := rnibDataService.PingRnib()
 247         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 1)
 248         assert.True(t, res)
 249 }
 250
 251 func TestPingRnibOkOtherError(t *testing.T) {
 252         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 253
 254         var nodeIds []*entities.NbIdentity = nil
 255         mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
 256         readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
 257
 258         res := rnibDataService.PingRnib()
 259         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 1)
 260         assert.True(t, res)
 261 }
 262
 263 //func TestConnFailureThenSuccessGetNodebIdList(t *testing.T) {
 264 //      rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 265 //
 266 //      var nilNodeIds []*entities.NbIdentity = nil
 267 //      nodeIds := []*entities.NbIdentity{}
 268 //      mockErr := &common.InternalError{Err: &net.OpError{Err:fmt.Errorf("connection error")}}
 269 //      //readerMock.On("GetListNodebIds").Return(nilNodeIds, mockErr)
 270 //      //readerMock.On("GetListNodebIds").Return(nodeIds, nil)
 271 //
 272 //      res, err := rnibDataService.GetListNodebIds()
 273 //      readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 2)
 274 //      assert.True(t, strings.Contains(err.Error(),"connection failure", ))
 275 //      assert.Equal(t, nodeIds, res)
 276 //}