E2Manager/managers/e2t_keep_alive_worker_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 package managers
  18
  19 import (
  20         "e2mgr/configuration"
  21         "e2mgr/logger"
  22         "e2mgr/mocks"
  23         "e2mgr/rmrCgo"
  24         "e2mgr/services"
  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/pkg/errors"
  28         "github.com/stretchr/testify/mock"
  29         "testing"
  30         "time"
  31 )
  32
  33 func initE2TKeepAliveTest(t *testing.T) (*mocks.RmrMessengerMock, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.E2TShutdownManagerMock, *E2TKeepAliveWorker) {
  34         logger, err := logger.InitLogger(logger.DebugLevel)
  35         if err != nil {
  36                 t.Errorf("#... - failed to initialize logger, error: %s", err)
  37         }
  38         config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3, KeepAliveResponseTimeoutMs: 400, KeepAliveDelayMs: 100}
  39
  40         readerMock := &mocks.RnibReaderMock{}
  41         writerMock := &mocks.RnibWriterMock{}
  42         e2tShutdownManagerMock := &mocks.E2TShutdownManagerMock{}
  43
  44         rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
  45         e2tInstancesManager := NewE2TInstancesManager(rnibDataService, logger)
  46
  47         rmrMessengerMock := &mocks.RmrMessengerMock{}
  48         rmrSender := initRmrSender(rmrMessengerMock, logger)
  49
  50         e2tKeepAliveWorker := NewE2TKeepAliveWorker(logger, rmrSender, e2tInstancesManager, e2tShutdownManagerMock, config)
  51
  52         return rmrMessengerMock, readerMock, writerMock, e2tShutdownManagerMock, &e2tKeepAliveWorker
  53 }
  54
  55 func TestSendKeepAliveRequest(t *testing.T) {
  56         rmrMessengerMock, _, _, _, e2tKeepAliveWorker := initE2TKeepAliveTest(t)
  57
  58         rmrMessengerMock.On("SendMsg", mock.Anything, false).Return(&rmrCgo.MBuf{}, nil)
  59
  60         e2tKeepAliveWorker.SendKeepAliveRequest()
  61
  62         var payload, xAction []byte
  63         req := rmrCgo.NewMBuf(rmrCgo.E2_TERM_KEEP_ALIVE_REQ, 0, "", &payload, &xAction)
  64
  65         rmrMessengerMock.AssertCalled(t, "SendMsg", req, false)
  66 }
  67
  68 func TestShutdownExpiredE2T_InternalError(t *testing.T) {
  69         rmrMessengerMock, readerMock, _, _, e2tKeepAliveWorker := initE2TKeepAliveTest(t)
  70
  71         readerMock.On("GetE2TAddresses").Return([]string{}, common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")))
  72
  73         e2tKeepAliveWorker.E2TKeepAliveExpired()
  74
  75         rmrMessengerMock.AssertNotCalled(t, "Shutdown")
  76 }
  77
  78 func TestShutdownExpiredE2T_NoAddresses(t *testing.T) {
  79         rmrMessengerMock, readerMock, _, _, e2tKeepAliveWorker := initE2TKeepAliveTest(t)
  80
  81         addresses := []string{}
  82
  83         readerMock.On("GetE2TAddresses").Return(addresses, nil)
  84
  85         e2tKeepAliveWorker.E2TKeepAliveExpired()
  86
  87         rmrMessengerMock.AssertNotCalled(t, "Shutdown")
  88 }
  89
  90 func TestShutdownExpiredE2T_NotExpired_InternalError(t *testing.T) {
  91         rmrMessengerMock, readerMock, _, _, e2tKeepAliveWorker := initE2TKeepAliveTest(t)
  92
  93         addresses := []string{E2TAddress,E2TAddress2}
  94         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
  95         e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"}
  96         e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
  97         e2tInstance2.AssociatedRanList = []string{"test4","test5","test6", "test7"}
  98
  99         readerMock.On("GetE2TAddresses").Return(addresses, nil)
 100         readerMock.On("GetE2TInstances",addresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")))
 101
 102         e2tKeepAliveWorker.E2TKeepAliveExpired()
 103
 104         rmrMessengerMock.AssertNotCalled(t, "Shutdown")
 105 }
 106
 107 func TestShutdownExpiredE2T_NoE2T(t *testing.T) {
 108         rmrMessengerMock, readerMock, _, _, e2tKeepAliveWorker := initE2TKeepAliveTest(t)
 109
 110         readerMock.On("GetE2TAddresses").Return([]string{}, common.NewResourceNotFoundError("not found"))
 111
 112         e2tKeepAliveWorker.E2TKeepAliveExpired()
 113
 114         rmrMessengerMock.AssertNotCalled(t, "Shutdown")
 115 }
 116
 117 func TestShutdownExpiredE2T_NotExpired(t *testing.T) {
 118         rmrMessengerMock, readerMock, _, _, e2tKeepAliveWorker := initE2TKeepAliveTest(t)
 119
 120         addresses := []string{E2TAddress,E2TAddress2}
 121         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 122         e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"}
 123         e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
 124         e2tInstance2.AssociatedRanList = []string{"test4","test5","test6", "test7"}
 125
 126         readerMock.On("GetE2TAddresses").Return(addresses, nil)
 127         readerMock.On("GetE2TInstances",addresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
 128
 129         e2tKeepAliveWorker.E2TKeepAliveExpired()
 130
 131         rmrMessengerMock.AssertNotCalled(t, "Shutdown")
 132 }
 133
 134 func TestShutdownExpiredE2T_One_E2TExpired(t *testing.T) {
 135         _, readerMock, _, e2tShutdownManagerMock, e2tKeepAliveWorker := initE2TKeepAliveTest(t)
 136
 137         addresses := []string{E2TAddress,E2TAddress2}
 138         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 139         e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"}
 140
 141         time.Sleep(time.Duration(400) * time.Millisecond)
 142
 143         e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
 144         e2tInstance2.AssociatedRanList = []string{"test4","test5","test6", "test7"}
 145
 146         readerMock.On("GetE2TAddresses").Return(addresses, nil)
 147         readerMock.On("GetE2TInstances",addresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
 148         e2tShutdownManagerMock.On("Shutdown", e2tInstance1).Return(nil)
 149
 150         e2tKeepAliveWorker.E2TKeepAliveExpired()
 151
 152         e2tShutdownManagerMock.AssertNumberOfCalls(t, "Shutdown", 1)
 153 }
 154
 155 func TestShutdownExpiredE2T_Two_E2TExpired(t *testing.T) {
 156         _, readerMock, _, e2tShutdownManagerMock, e2tKeepAliveWorker := initE2TKeepAliveTest(t)
 157
 158         addresses := []string{E2TAddress,E2TAddress2}
 159         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 160         e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"}
 161
 162         e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
 163         e2tInstance2.AssociatedRanList = []string{"test4","test5","test6", "test7"}
 164
 165         time.Sleep(time.Duration(400) * time.Millisecond)
 166
 167         readerMock.On("GetE2TAddresses").Return(addresses, nil)
 168         readerMock.On("GetE2TInstances",addresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
 169         e2tShutdownManagerMock.On("Shutdown", e2tInstance1).Return(nil)
 170         e2tShutdownManagerMock.On("Shutdown", e2tInstance2).Return(nil)
 171
 172         e2tKeepAliveWorker.E2TKeepAliveExpired()
 173
 174         e2tShutdownManagerMock.AssertNumberOfCalls(t, "Shutdown", 2)
 175 }
 176
 177 func TestExecute_Two_E2TExpired(t *testing.T) {
 178         rmrMessengerMock, readerMock, _, e2tShutdownManagerMock, e2tKeepAliveWorker := initE2TKeepAliveTest(t)
 179
 180         addresses := []string{E2TAddress,E2TAddress2}
 181         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 182         e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"}
 183
 184         readerMock.On("GetE2TAddresses").Return(addresses, nil)
 185         readerMock.On("GetE2TInstances",addresses).Return([]*entities.E2TInstance{e2tInstance1}, nil)
 186         e2tShutdownManagerMock.On("Shutdown", e2tInstance1).Return(nil)
 187         rmrMessengerMock.On("SendMsg", mock.Anything, false).Return(&rmrCgo.MBuf{}, nil)
 188
 189         go e2tKeepAliveWorker.Execute()
 190
 191         time.Sleep(time.Duration(500) * time.Millisecond)
 192
 193         var payload, xAction []byte
 194         req := rmrCgo.NewMBuf(rmrCgo.E2_TERM_KEEP_ALIVE_REQ, 0, "", &payload, &xAction)
 195
 196         rmrMessengerMock.AssertCalled(t, "SendMsg", req, false)
 197         e2tShutdownManagerMock.AssertCalled(t, "Shutdown", e2tInstance1)
 198 }