E2Manager/handlers/httpmsghandlers/x2_reset_request_handler_test.go

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