E2Manager/handlers/x2_reset_request_handler_test.go

   1 package handlers
   2
   3 import (
   4         "e2mgr/configuration"
   5         "e2mgr/e2managererrors"
   6         "e2mgr/mocks"
   7         "e2mgr/models"
   8         "e2mgr/rNibWriter"
   9         "e2mgr/rmrCgo"
  10         "fmt"
  11         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  12         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  13         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
  14         "github.com/stretchr/testify/assert"
  15         "github.com/stretchr/testify/mock"
  16         "testing"
  17         "time"
  18 )
  19
  20
  21 func TestHandleSuccessfulDefaultCause(t *testing.T){
  22         log := initLog(t)
  23
  24         curTime := time.Now()
  25         ranName := "test1"
  26
  27         readerMock := &mocks.RnibReaderMock{}
  28         readerProvider := func() reader.RNibReader {
  29                 return readerMock
  30         }
  31         writerMock := &mocks.RnibWriterMock{}
  32         writerProvider := func() rNibWriter.RNibWriter {
  33                 return writerMock
  34         }
  35         // o&m intervention
  36         payload:= []byte {0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
  37         xaction := []byte(ranName)
  38         msg:= rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xaction)
  39         rmrMessengerMock := &mocks.RmrMessengerMock{}
  40         rmrMessengerMock.On("SendMsg",msg,mock.Anything).Return(msg,nil)
  41
  42         config := configuration.ParseConfiguration()
  43         rmrService:=getRmrService(rmrMessengerMock, log)
  44         handler := NewX2ResetRequestHandler(rmrService, config, writerProvider, readerProvider)
  45
  46         var nodeb = &entities.NodebInfo{ConnectionStatus:  entities.ConnectionStatus_CONNECTED }
  47         readerMock.On("GetNodeb",ranName).Return(nodeb, nil)
  48
  49         actual := handler.Handle(log, models.ResetRequest{RanName: ranName , StartTime: curTime})
  50
  51         assert.Nil(t, actual)
  52
  53         v, ok := rmrService.E2sessions[ranName]
  54         assert.True(t, ok)
  55
  56         assert.Equal(t, v.Request.RanName, ranName)
  57
  58         assert.Equal(t, v.SessionStart ,curTime)
  59 }
  60
  61 func TestHandleSuccessfulRequestedCause(t *testing.T){
  62         log := initLog(t)
  63
  64         curTime := time.Now()
  65         ranName := "test1"
  66
  67         readerMock := &mocks.RnibReaderMock{}
  68         readerProvider := func() reader.RNibReader {
  69                 return readerMock
  70         }
  71         writerMock := &mocks.RnibWriterMock{}
  72         writerProvider := func() rNibWriter.RNibWriter {
  73                 return writerMock
  74         }
  75
  76         payload:= []byte {0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
  77         xaction := []byte(ranName)
  78         msg:= rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xaction)
  79         rmrMessengerMock := &mocks.RmrMessengerMock{}
  80         rmrMessengerMock.On("SendMsg",msg,mock.Anything).Return(msg,nil)
  81
  82         config := configuration.ParseConfiguration()
  83         rmrService:=getRmrService(rmrMessengerMock, log)
  84         handler := NewX2ResetRequestHandler(rmrService, config, writerProvider, readerProvider)
  85
  86         var nodeb = &entities.NodebInfo{ConnectionStatus:  entities.ConnectionStatus_CONNECTED }
  87         readerMock.On("GetNodeb",ranName).Return(nodeb, nil)
  88
  89         actual := handler.Handle(log, models.ResetRequest{RanName: ranName , Cause:"protocol:transfer-syntax-error", StartTime: curTime})
  90
  91         assert.Nil(t, actual)
  92
  93         v, ok := rmrService.E2sessions[ranName]
  94         assert.True(t, ok)
  95
  96         assert.Equal(t, v.Request.RanName, ranName)
  97
  98         assert.Equal(t, v.SessionStart ,curTime)
  99 }
 100
 101 func TestHandleFailureUnknownCause(t *testing.T){
 102         log := initLog(t)
 103
 104         curTime := time.Now()
 105         ranName := "test1"
 106
 107         readerMock := &mocks.RnibReaderMock{}
 108         readerProvider := func() reader.RNibReader {
 109                 return readerMock
 110         }
 111         writerMock := &mocks.RnibWriterMock{}
 112         writerProvider := func() rNibWriter.RNibWriter {
 113                 return writerMock
 114         }
 115
 116
 117         rmrMessengerMock := &mocks.RmrMessengerMock{}
 118
 119
 120         config := configuration.ParseConfiguration()
 121         rmrService:=getRmrService(rmrMessengerMock, log)
 122         handler := NewX2ResetRequestHandler(rmrService, config, writerProvider, readerProvider)
 123
 124         var nodeb = &entities.NodebInfo{ConnectionStatus:  entities.ConnectionStatus_CONNECTED }
 125         readerMock.On("GetNodeb",ranName).Return(nodeb, nil)
 126
 127         actual := handler.Handle(log, models.ResetRequest{RanName: ranName , Cause:"XXX", StartTime: curTime})
 128
 129         assert.IsType(t, e2managererrors.NewRequestValidationError(), actual)
 130
 131         _, ok := rmrService.E2sessions[ranName]
 132         assert.False(t, ok)
 133 }
 134
 135 func TestHandleFailureWrongState(t *testing.T){
 136         log := initLog(t)
 137
 138         curTime := time.Now()
 139         ranName := "test1"
 140
 141         readerMock := &mocks.RnibReaderMock{}
 142         readerProvider := func() reader.RNibReader {
 143                 return readerMock
 144         }
 145         writerMock := &mocks.RnibWriterMock{}
 146         writerProvider := func() rNibWriter.RNibWriter {
 147                 return writerMock
 148         }
 149
 150
 151         rmrMessengerMock := &mocks.RmrMessengerMock{}
 152
 153
 154         config := configuration.ParseConfiguration()
 155         rmrService:=getRmrService(rmrMessengerMock, log)
 156         handler := NewX2ResetRequestHandler(rmrService, config, writerProvider, readerProvider)
 157
 158         var nodeb = &entities.NodebInfo{ConnectionStatus:  entities.ConnectionStatus_DISCONNECTED }
 159         readerMock.On("GetNodeb",ranName).Return(nodeb, nil)
 160
 161         actual := handler.Handle(log, models.ResetRequest{RanName: ranName ,  StartTime: curTime})
 162
 163         assert.IsType(t, e2managererrors.NewWrongStateError(entities.ConnectionStatus_name[int32(nodeb.ConnectionStatus)]), actual)
 164
 165         _, ok := rmrService.E2sessions[ranName]
 166         assert.False(t, ok)
 167 }
 168
 169
 170
 171 func TestHandleFailureRanNotFound(t *testing.T){
 172         log := initLog(t)
 173
 174         curTime := time.Now()
 175         ranName := "test1"
 176
 177         readerMock := &mocks.RnibReaderMock{}
 178         readerProvider := func() reader.RNibReader {
 179                 return readerMock
 180         }
 181         writerMock := &mocks.RnibWriterMock{}
 182         writerProvider := func() rNibWriter.RNibWriter {
 183                 return writerMock
 184         }
 185
 186
 187         rmrMessengerMock := &mocks.RmrMessengerMock{}
 188
 189
 190         config := configuration.ParseConfiguration()
 191         rmrService:=getRmrService(rmrMessengerMock, log)
 192         handler := NewX2ResetRequestHandler(rmrService, config, writerProvider, readerProvider)
 193
 194         readerMock.On("GetNodeb",ranName).Return(&entities.NodebInfo{}, common.NewResourceNotFoundError(fmt.Errorf("nodeb not found")))
 195
 196         actual := handler.Handle(log, models.ResetRequest{RanName: ranName ,  StartTime: curTime})
 197
 198         assert.IsType(t, e2managererrors.NewResourceNotFoundError(), actual)
 199
 200         _, ok := rmrService.E2sessions[ranName]
 201         assert.False(t, ok)
 202 }
 203
 204
 205 func TestHandleFailureRnibError(t *testing.T){
 206         log := initLog(t)
 207
 208         curTime := time.Now()
 209         ranName := "test1"
 210
 211         readerMock := &mocks.RnibReaderMock{}
 212         readerProvider := func() reader.RNibReader {
 213                 return readerMock
 214         }
 215         writerMock := &mocks.RnibWriterMock{}
 216         writerProvider := func() rNibWriter.RNibWriter {
 217                 return writerMock
 218         }
 219
 220
 221         rmrMessengerMock := &mocks.RmrMessengerMock{}
 222
 223
 224         config := configuration.ParseConfiguration()
 225         rmrService:=getRmrService(rmrMessengerMock, log)
 226         handler := NewX2ResetRequestHandler(rmrService, config, writerProvider, readerProvider)
 227
 228         readerMock.On("GetNodeb",ranName).Return(&entities.NodebInfo{}, common.NewInternalError(fmt.Errorf("internal error")))
 229
 230         actual := handler.Handle(log, models.ResetRequest{RanName: ranName ,  StartTime: curTime})
 231
 232         assert.IsType(t, e2managererrors.NewRnibDbError(), actual)
 233
 234         _, ok := rmrService.E2sessions[ranName]
 235         assert.False(t, ok)
 236 }
 237
 238
 239 func TestHandleFailureRmrError(t *testing.T){
 240         log := initLog(t)
 241
 242         curTime := time.Now()
 243         ranName := "test1"
 244
 245         readerMock := &mocks.RnibReaderMock{}
 246         readerProvider := func() reader.RNibReader {
 247                 return readerMock
 248         }
 249         writerMock := &mocks.RnibWriterMock{}
 250         writerProvider := func() rNibWriter.RNibWriter {
 251                 return writerMock
 252         }
 253         // o&m intervention
 254         payload:= []byte {0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
 255         xaction := []byte(ranName)
 256         msg:= rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xaction)
 257         rmrMessengerMock := &mocks.RmrMessengerMock{}
 258         rmrMessengerMock.On("SendMsg",msg,mock.Anything).Return(&rmrCgo.MBuf{},fmt.Errorf("rmr error"))
 259
 260         config := configuration.ParseConfiguration()
 261         rmrService:=getRmrService(rmrMessengerMock, log)
 262         handler := NewX2ResetRequestHandler(rmrService, config, writerProvider, readerProvider)
 263
 264         var nodeb = &entities.NodebInfo{ConnectionStatus:  entities.ConnectionStatus_CONNECTED }
 265         readerMock.On("GetNodeb",ranName).Return(nodeb, nil)
 266
 267         actual := handler.Handle(log, models.ResetRequest{RanName: ranName , StartTime: curTime})
 268
 269         assert.IsType(t, e2managererrors.NewRmrError(), actual)
 270
 271         _, ok := rmrService.E2sessions[ranName]
 272         assert.False(t, ok)
 273 }