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