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