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 package services
  21
  22 import (
  23         "e2mgr/configuration"
  24         "e2mgr/logger"
  25         "e2mgr/mocks"
  26         "fmt"
  27         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  28         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  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, RnibWriter: configuration.RnibWriterConfig{RanManipulationMessageChannel: "RAN_MANIPULATION", StateChangeMessageChannel: "RAN_CONNECTION_STATUS_CHANGE"}}
  46
  47         readerMock := &mocks.RnibReaderMock{}
  48
  49         writerMock := &mocks.RnibWriterMock{}
  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         writerMock.On("SaveNodeb", nodebInfo).Return(nil)
  62
  63         rnibDataService.SaveNodeb(nodebInfo)
  64         writerMock.AssertNumberOfCalls(t, "SaveNodeb", 1)
  65 }
  66
  67 func TestConnFailureSaveNodeb(t *testing.T) {
  68         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
  69
  70         nodebInfo := &entities.NodebInfo{}
  71         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
  72         writerMock.On("SaveNodeb", nodebInfo).Return(mockErr)
  73
  74         rnibDataService.SaveNodeb(nodebInfo)
  75         writerMock.AssertNumberOfCalls(t, "SaveNodeb", 3)
  76 }
  77
  78 func TestNonConnFailureSaveNodeb(t *testing.T) {
  79         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
  80
  81         nodebInfo := &entities.NodebInfo{}
  82         mockErr := &common.InternalError{Err: fmt.Errorf("non connection failure")}
  83         writerMock.On("SaveNodeb", nodebInfo).Return(mockErr)
  84
  85         rnibDataService.SaveNodeb(nodebInfo)
  86         writerMock.AssertNumberOfCalls(t, "SaveNodeb", 1)
  87 }
  88
  89 func TestSuccessfulUpdateNodebInfo(t *testing.T) {
  90         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
  91
  92         nodebInfo := &entities.NodebInfo{}
  93         writerMock.On("UpdateNodebInfo", nodebInfo).Return(nil)
  94
  95         rnibDataService.UpdateNodebInfo(nodebInfo)
  96         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
  97 }
  98
  99 func TestConnFailureUpdateNodebInfo(t *testing.T) {
 100         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 101
 102         nodebInfo := &entities.NodebInfo{}
 103         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 104         writerMock.On("UpdateNodebInfo", nodebInfo).Return(mockErr)
 105
 106         rnibDataService.UpdateNodebInfo(nodebInfo)
 107         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 3)
 108 }
 109
 110 func TestSuccessfulSaveRanLoadInformation(t *testing.T) {
 111         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 112
 113         var ranName string = "abcd"
 114         ranLoadInformation := &entities.RanLoadInformation{}
 115         writerMock.On("SaveRanLoadInformation", ranName, ranLoadInformation).Return(nil)
 116
 117         rnibDataService.SaveRanLoadInformation(ranName, ranLoadInformation)
 118         writerMock.AssertNumberOfCalls(t, "SaveRanLoadInformation", 1)
 119 }
 120
 121 func TestConnFailureSaveRanLoadInformation(t *testing.T) {
 122         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 123
 124         var ranName string = "abcd"
 125         ranLoadInformation := &entities.RanLoadInformation{}
 126         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 127         writerMock.On("SaveRanLoadInformation", ranName, ranLoadInformation).Return(mockErr)
 128
 129         rnibDataService.SaveRanLoadInformation(ranName, ranLoadInformation)
 130         writerMock.AssertNumberOfCalls(t, "SaveRanLoadInformation", 3)
 131 }
 132
 133 func TestSuccessfulGetNodeb(t *testing.T) {
 134         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 135
 136         invName := "abcd"
 137         nodebInfo := &entities.NodebInfo{}
 138         readerMock.On("GetNodeb", invName).Return(nodebInfo, nil)
 139
 140         res, err := rnibDataService.GetNodeb(invName)
 141         readerMock.AssertNumberOfCalls(t, "GetNodeb", 1)
 142         assert.Equal(t, nodebInfo, res)
 143         assert.Nil(t, err)
 144 }
 145
 146 func TestConnFailureGetNodeb(t *testing.T) {
 147         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 148
 149         invName := "abcd"
 150         var nodeb *entities.NodebInfo = nil
 151         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 152         readerMock.On("GetNodeb", invName).Return(nodeb, mockErr)
 153
 154         res, err := rnibDataService.GetNodeb(invName)
 155         readerMock.AssertNumberOfCalls(t, "GetNodeb", 3)
 156         assert.True(t, strings.Contains(err.Error(), "connection error"))
 157         assert.Equal(t, nodeb, res)
 158 }
 159
 160 func TestSuccessfulGetNodebIdList(t *testing.T) {
 161         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 162
 163         nodeIds := []*entities.NbIdentity{}
 164         readerMock.On("GetListNodebIds").Return(nodeIds, nil)
 165
 166         res, err := rnibDataService.GetListNodebIds()
 167         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 1)
 168         assert.Equal(t, nodeIds, res)
 169         assert.Nil(t, err)
 170 }
 171
 172 func TestConnFailureGetNodebIdList(t *testing.T) {
 173         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 174
 175         var nodeIds []*entities.NbIdentity = nil
 176         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 177         readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
 178
 179         res, err := rnibDataService.GetListNodebIds()
 180         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 3)
 181         assert.True(t, strings.Contains(err.Error(), "connection error"))
 182         assert.Equal(t, nodeIds, res)
 183 }
 184
 185 func TestConnFailureTwiceGetNodebIdList(t *testing.T) {
 186         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 187
 188         invName := "abcd"
 189         var nodeb *entities.NodebInfo = nil
 190         var nodeIds []*entities.NbIdentity = nil
 191         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 192         readerMock.On("GetNodeb", invName).Return(nodeb, mockErr)
 193         readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
 194
 195         res, err := rnibDataService.GetListNodebIds()
 196         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 3)
 197         assert.True(t, strings.Contains(err.Error(), "connection error"))
 198         assert.Equal(t, nodeIds, res)
 199
 200         res2, err := rnibDataService.GetNodeb(invName)
 201         readerMock.AssertNumberOfCalls(t, "GetNodeb", 3)
 202         assert.True(t, strings.Contains(err.Error(), "connection error"))
 203         assert.Equal(t, nodeb, res2)
 204 }
 205
 206 func TestConnFailureWithAnotherConfig(t *testing.T) {
 207         rnibDataService, readerMock, _ := setupRnibDataServiceTestWithMaxAttempts(t, 5)
 208
 209         var nodeIds []*entities.NbIdentity = nil
 210         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 211         readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
 212
 213         res, err := rnibDataService.GetListNodebIds()
 214         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 5)
 215         assert.True(t, strings.Contains(err.Error(), "connection error"))
 216         assert.Equal(t, nodeIds, res)
 217 }
 218
 219 func TestPingRnibConnFailure(t *testing.T) {
 220         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 221
 222         var nodeIds []*entities.NbIdentity = nil
 223         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 224         readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
 225
 226         res := rnibDataService.PingRnib()
 227         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 3)
 228         assert.False(t, res)
 229 }
 230
 231 func TestPingRnibOkNoError(t *testing.T) {
 232         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 233
 234         var nodeIds []*entities.NbIdentity = nil
 235         readerMock.On("GetListNodebIds").Return(nodeIds, nil)
 236
 237         res := rnibDataService.PingRnib()
 238         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 1)
 239         assert.True(t, res)
 240 }
 241
 242 func TestPingRnibOkOtherError(t *testing.T) {
 243         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 244
 245         var nodeIds []*entities.NbIdentity = nil
 246         mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
 247         readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
 248
 249         res := rnibDataService.PingRnib()
 250         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 1)
 251         assert.True(t, res)
 252 }
 253
 254 func TestSuccessfulUpdateNodebInfoOnConnectionStatusInversion(t *testing.T) {
 255         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 256         event := "event"
 257
 258         nodebInfo := &entities.NodebInfo{}
 259         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", nodebInfo, event).Return(nil)
 260
 261         rnibDataService.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, event)
 262         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfoOnConnectionStatusInversion", 1)
 263 }
 264
 265 func TestConnFailureUpdateNodebInfoOnConnectionStatusInversion(t *testing.T) {
 266         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 267         event := "event"
 268
 269         nodebInfo := &entities.NodebInfo{}
 270         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 271         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", nodebInfo, event).Return(mockErr)
 272
 273         rnibDataService.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, event)
 274         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfoOnConnectionStatusInversion", 3)
 275 }
 276
 277 func TestGetE2TInstanceConnFailure(t *testing.T) {
 278         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 279
 280         address := "10.10.5.20:3200"
 281         var e2tInstance *entities.E2TInstance = nil
 282         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 283         readerMock.On("GetE2TInstance", address).Return(e2tInstance, mockErr)
 284
 285         res, err := rnibDataService.GetE2TInstance(address)
 286         readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 3)
 287         assert.Nil(t, res)
 288         assert.NotNil(t, err)
 289 }
 290
 291 func TestGetE2TInstanceOkNoError(t *testing.T) {
 292         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 293
 294         address := "10.10.5.20:3200"
 295         e2tInstance := &entities.E2TInstance{}
 296         readerMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
 297
 298         res, err := rnibDataService.GetE2TInstance(address)
 299         readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 1)
 300         assert.Nil(t, err)
 301         assert.Equal(t, e2tInstance, res)
 302 }
 303
 304 func TestGetE2TInstanceOkOtherError(t *testing.T) {
 305         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 306
 307         address := "10.10.5.20:3200"
 308         var e2tInstance *entities.E2TInstance = nil
 309         mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
 310         readerMock.On("GetE2TInstance", address).Return(e2tInstance, mockErr)
 311
 312         res, err := rnibDataService.GetE2TInstance(address)
 313         readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 1)
 314         assert.Nil(t, res)
 315         assert.NotNil(t, err)
 316 }
 317
 318 func TestRemoveEnbConnFailure(t *testing.T) {
 319         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 320
 321         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 322         nodebInfo := &entities.NodebInfo{}
 323         writerMock.On("RemoveEnb", nodebInfo).Return(mockErr)
 324
 325         err := rnibDataService.RemoveEnb(nodebInfo)
 326         writerMock.AssertNumberOfCalls(t, "RemoveEnb", 3)
 327         assert.NotNil(t, err)
 328 }
 329
 330 func TestRemoveEnbOkNoError(t *testing.T) {
 331         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 332
 333         nodebInfo := &entities.NodebInfo{}
 334         writerMock.On("RemoveEnb", nodebInfo).Return(nil)
 335
 336         err := rnibDataService.RemoveEnb(nodebInfo)
 337         writerMock.AssertNumberOfCalls(t, "RemoveEnb", 1)
 338         assert.Nil(t, err)
 339 }
 340
 341 func TestRemoveEnbOtherError(t *testing.T) {
 342         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 343
 344         mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
 345         nodebInfo := &entities.NodebInfo{}
 346         writerMock.On("RemoveEnb", nodebInfo).Return(mockErr)
 347
 348         err := rnibDataService.RemoveEnb(nodebInfo)
 349         writerMock.AssertNumberOfCalls(t, "RemoveEnb", 1)
 350         assert.NotNil(t, err)
 351 }