E2Manager/handlers/httpmsghandlers/x2_reset_request_handler_test.go

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