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