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 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
  18 //  platform project (RICP).
  19
  20
  21 package services
  22
  23 import (
  24         "e2mgr/configuration"
  25         "e2mgr/logger"
  26         "e2mgr/mocks"
  27         "fmt"
  28         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  29         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  30         "github.com/stretchr/testify/assert"
  31         "net"
  32         "strings"
  33         "testing"
  34 )
  35
  36 func setupRnibDataServiceTest(t *testing.T) (*rNibDataService, *mocks.RnibReaderMock, *mocks.RnibWriterMock) {
  37         return setupRnibDataServiceTestWithMaxAttempts(t, 3)
  38 }
  39
  40 func setupRnibDataServiceTestWithMaxAttempts(t *testing.T, maxAttempts int) (*rNibDataService, *mocks.RnibReaderMock, *mocks.RnibWriterMock) {
  41         logger, err := logger.InitLogger(logger.DebugLevel)
  42         if err != nil {
  43                 t.Errorf("#... - failed to initialize logger, error: %s", err)
  44         }
  45
  46         config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: maxAttempts}
  47
  48         readerMock := &mocks.RnibReaderMock{}
  49
  50
  51         writerMock := &mocks.RnibWriterMock{}
  52
  53
  54         rnibDataService := NewRnibDataService(logger, config, readerMock, writerMock)
  55         assert.NotNil(t, rnibDataService)
  56
  57         return rnibDataService, readerMock, writerMock
  58 }
  59
  60 func TestSuccessfulSaveNodeb(t *testing.T) {
  61         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
  62
  63         nodebInfo := &entities.NodebInfo{}
  64         nbIdentity := &entities.NbIdentity{}
  65         writerMock.On("SaveNodeb", nbIdentity, nodebInfo).Return(nil)
  66
  67         rnibDataService.SaveNodeb(nbIdentity, nodebInfo)
  68         writerMock.AssertNumberOfCalls(t, "SaveNodeb", 1)
  69 }
  70
  71 func TestConnFailureSaveNodeb(t *testing.T) {
  72         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
  73
  74         nodebInfo := &entities.NodebInfo{}
  75         nbIdentity := &entities.NbIdentity{}
  76         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
  77         writerMock.On("SaveNodeb", nbIdentity, nodebInfo).Return(mockErr)
  78
  79         rnibDataService.SaveNodeb(nbIdentity, nodebInfo)
  80         writerMock.AssertNumberOfCalls(t, "SaveNodeb", 3)
  81 }
  82
  83 func TestNonConnFailureSaveNodeb(t *testing.T) {
  84         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
  85
  86         nodebInfo := &entities.NodebInfo{}
  87         nbIdentity := &entities.NbIdentity{}
  88         mockErr := &common.InternalError{Err: fmt.Errorf("non connection failure")}
  89         writerMock.On("SaveNodeb", nbIdentity, nodebInfo).Return(mockErr)
  90
  91         rnibDataService.SaveNodeb(nbIdentity, nodebInfo)
  92         writerMock.AssertNumberOfCalls(t, "SaveNodeb", 1)
  93 }
  94
  95 func TestSuccessfulUpdateNodebInfo(t *testing.T) {
  96         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
  97
  98         nodebInfo := &entities.NodebInfo{}
  99         writerMock.On("UpdateNodebInfo", nodebInfo).Return(nil)
 100
 101         rnibDataService.UpdateNodebInfo(nodebInfo)
 102         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
 103 }
 104
 105 func TestConnFailureUpdateNodebInfo(t *testing.T) {
 106         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 107
 108         nodebInfo := &entities.NodebInfo{}
 109         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 110         writerMock.On("UpdateNodebInfo", nodebInfo).Return(mockErr)
 111
 112         rnibDataService.UpdateNodebInfo(nodebInfo)
 113         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 3)
 114 }
 115
 116 func TestSuccessfulSaveRanLoadInformation(t *testing.T) {
 117         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 118
 119         var ranName string = "abcd"
 120         ranLoadInformation := &entities.RanLoadInformation{}
 121         writerMock.On("SaveRanLoadInformation", ranName, ranLoadInformation).Return(nil)
 122
 123         rnibDataService.SaveRanLoadInformation(ranName, ranLoadInformation)
 124         writerMock.AssertNumberOfCalls(t, "SaveRanLoadInformation", 1)
 125 }
 126
 127 func TestConnFailureSaveRanLoadInformation(t *testing.T) {
 128         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 129
 130         var ranName string = "abcd"
 131         ranLoadInformation := &entities.RanLoadInformation{}
 132         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 133         writerMock.On("SaveRanLoadInformation", ranName, ranLoadInformation).Return(mockErr)
 134
 135         rnibDataService.SaveRanLoadInformation(ranName, ranLoadInformation)
 136         writerMock.AssertNumberOfCalls(t, "SaveRanLoadInformation", 3)
 137 }
 138
 139 func TestSuccessfulGetNodeb(t *testing.T) {
 140         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 141
 142         invName := "abcd"
 143         nodebInfo := &entities.NodebInfo{}
 144         readerMock.On("GetNodeb", invName).Return(nodebInfo, nil)
 145
 146         res, err := rnibDataService.GetNodeb(invName)
 147         readerMock.AssertNumberOfCalls(t, "GetNodeb", 1)
 148         assert.Equal(t, nodebInfo, res)
 149         assert.Nil(t, err)
 150 }
 151
 152 func TestConnFailureGetNodeb(t *testing.T) {
 153         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 154
 155         invName := "abcd"
 156         var nodeb *entities.NodebInfo = nil
 157         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 158         readerMock.On("GetNodeb", invName).Return(nodeb, mockErr)
 159
 160         res, err := rnibDataService.GetNodeb(invName)
 161         readerMock.AssertNumberOfCalls(t, "GetNodeb", 3)
 162         assert.True(t, strings.Contains(err.Error(), "connection error", ))
 163         assert.Equal(t, nodeb, res)
 164 }
 165
 166 func TestSuccessfulGetNodebIdList(t *testing.T) {
 167         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 168
 169         nodeIds := []*entities.NbIdentity{}
 170         readerMock.On("GetListNodebIds").Return(nodeIds, nil)
 171
 172         res, err := rnibDataService.GetListNodebIds()
 173         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 1)
 174         assert.Equal(t, nodeIds, res)
 175         assert.Nil(t, err)
 176 }
 177
 178 func TestConnFailureGetNodebIdList(t *testing.T) {
 179         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 180
 181         var nodeIds []*entities.NbIdentity = nil
 182         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 183         readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
 184
 185         res, err := rnibDataService.GetListNodebIds()
 186         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 3)
 187         assert.True(t, strings.Contains(err.Error(), "connection error", ))
 188         assert.Equal(t, nodeIds, res)
 189 }
 190
 191 func TestConnFailureTwiceGetNodebIdList(t *testing.T) {
 192         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 193
 194         invName := "abcd"
 195         var nodeb *entities.NodebInfo = nil
 196         var nodeIds []*entities.NbIdentity = nil
 197         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 198         readerMock.On("GetNodeb", invName).Return(nodeb, mockErr)
 199         readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
 200
 201         res, err := rnibDataService.GetListNodebIds()
 202         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 3)
 203         assert.True(t, strings.Contains(err.Error(), "connection error", ))
 204         assert.Equal(t, nodeIds, res)
 205
 206         res2, err := rnibDataService.GetNodeb(invName)
 207         readerMock.AssertNumberOfCalls(t, "GetNodeb", 3)
 208         assert.True(t, strings.Contains(err.Error(), "connection error", ))
 209         assert.Equal(t, nodeb, res2)
 210 }
 211
 212 func TestConnFailureWithAnotherConfig(t *testing.T) {
 213         rnibDataService, readerMock, _ := setupRnibDataServiceTestWithMaxAttempts(t, 5)
 214
 215         var nodeIds []*entities.NbIdentity = nil
 216         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 217         readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
 218
 219         res, err := rnibDataService.GetListNodebIds()
 220         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 5)
 221         assert.True(t, strings.Contains(err.Error(), "connection error", ))
 222         assert.Equal(t, nodeIds, res)
 223 }
 224
 225 func TestPingRnibConnFailure(t *testing.T) {
 226         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 227
 228         var nodeIds []*entities.NbIdentity = nil
 229         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 230         readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
 231
 232         res := rnibDataService.PingRnib()
 233         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 3)
 234         assert.False(t, res)
 235 }
 236
 237 func TestPingRnibOkNoError(t *testing.T) {
 238         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 239
 240         var nodeIds []*entities.NbIdentity = nil
 241         readerMock.On("GetListNodebIds").Return(nodeIds, nil)
 242
 243         res := rnibDataService.PingRnib()
 244         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 1)
 245         assert.True(t, res)
 246 }
 247
 248 func TestPingRnibOkOtherError(t *testing.T) {
 249         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 250
 251         var nodeIds []*entities.NbIdentity = nil
 252         mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
 253         readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
 254
 255         res := rnibDataService.PingRnib()
 256         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 1)
 257         assert.True(t, res)
 258 }
 259
 260 //func TestConnFailureThenSuccessGetNodebIdList(t *testing.T) {
 261 //      rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 262 //
 263 //      var nilNodeIds []*entities.NbIdentity = nil
 264 //      nodeIds := []*entities.NbIdentity{}
 265 //      mockErr := &common.InternalError{Err: &net.OpError{Err:fmt.Errorf("connection error")}}
 266 //      //readerMock.On("GetListNodebIds").Return(nilNodeIds, mockErr)
 267 //      //readerMock.On("GetListNodebIds").Return(nodeIds, nil)
 268 //
 269 //      res, err := rnibDataService.GetListNodebIds()
 270 //      readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 2)
 271 //      assert.True(t, strings.Contains(err.Error(),"connection failure", ))
 272 //      assert.Equal(t, nodeIds, res)
 273 //}
 274
 275 func TestGetE2TInstanceConnFailure(t *testing.T) {
 276         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 277
 278         address := "10.10.5.20:3200"
 279         var e2tInstance *entities.E2TInstance = nil
 280         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 281         readerMock.On("GetE2TInstance", address).Return(e2tInstance, mockErr)
 282
 283         res, err := rnibDataService.GetE2TInstance(address)
 284         readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 3)
 285         assert.Nil(t, res)
 286         assert.NotNil(t, err)
 287 }
 288
 289 func TestGetE2TInstanceOkNoError(t *testing.T) {
 290         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 291
 292         address := "10.10.5.20:3200"
 293         e2tInstance := &entities.E2TInstance{}
 294         readerMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
 295
 296         res, err := rnibDataService.GetE2TInstance(address)
 297         readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 1)
 298         assert.Nil(t, err)
 299         assert.Equal(t, e2tInstance, res)
 300 }
 301
 302 func TestGetE2TInstanceOkOtherError(t *testing.T) {
 303         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 304
 305         address := "10.10.5.20:3200"
 306         var e2tInstance *entities.E2TInstance = nil
 307         mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
 308         readerMock.On("GetE2TInstance", address).Return(e2tInstance, mockErr)
 309
 310         res, err := rnibDataService.GetE2TInstance(address)
 311         readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 1)
 312         assert.Nil(t, res)
 313         assert.NotNil(t, err)
 314 }