E2Manager/controllers/nodeb_controller_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 package controllers
  19
  20 import (
  21         "e2mgr/logger"
  22         "e2mgr/mocks"
  23         "e2mgr/models"
  24         "e2mgr/rNibWriter"
  25         "e2mgr/rmrCgo"
  26         "e2mgr/services"
  27         "e2mgr/sessions"
  28         "e2mgr/tests"
  29         "fmt"
  30         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  31         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  32         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
  33         "github.com/gorilla/mux"
  34         "github.com/pkg/errors"
  35         "github.com/stretchr/testify/assert"
  36         "github.com/stretchr/testify/mock"
  37         "io/ioutil"
  38         "net/http"
  39         "net/http/httptest"
  40         "testing"
  41 )
  42
  43 const x2SetupMessageType = "x2-setup"
  44
  45 func TestNewRequestController(t *testing.T) {
  46         rnibReaderProvider := func() reader.RNibReader {
  47                 return &mocks.RnibReaderMock{}
  48         }
  49         rnibWriterProvider := func() rNibWriter.RNibWriter {
  50                 return &mocks.RnibWriterMock{}
  51         }
  52
  53         assert.NotNil(t, NewNodebController(&logger.Logger{}, &services.RmrService{}, rnibReaderProvider, rnibWriterProvider))
  54 }
  55
  56 func TestHandleRequestSuccess(t *testing.T) {
  57         log, err := logger.InitLogger(logger.InfoLevel)
  58         if err != nil {
  59                 t.Errorf("#nodeb_controller_test.TestHandleRequestSuccess - failed to initialize logger, error: %s", err)
  60         }
  61
  62         rmrMessengerMock := &mocks.RmrMessengerMock{}
  63         mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
  64
  65         rmrMessengerMock.On("SendMsg",
  66                 mock.AnythingOfType(fmt.Sprintf("%T", mbuf)),
  67                 tests.MaxMsgSize).Return(mbuf, nil)
  68
  69         writer := httptest.NewRecorder()
  70
  71         handleRequest(writer, log, rmrMessengerMock, tests.GetHttpRequest(), x2SetupMessageType)
  72         assert.Equal(t, http.StatusOK, writer.Result().StatusCode)
  73 }
  74
  75 func TestHandleRequestFailure_InvalidRequestDetails(t *testing.T) {
  76         log, err := logger.InitLogger(logger.InfoLevel)
  77         if err != nil {
  78                 t.Errorf("#nodeb_controller_test.TestHandleRequestFailure - failed to initialize logger, error: %s", err)
  79         }
  80
  81         rmrMessengerMock := &mocks.RmrMessengerMock{}
  82         var mbuf *rmrCgo.MBuf
  83
  84         rmrMessengerMock.On("SendMsg",
  85                 mock.AnythingOfType(fmt.Sprintf("%T", mbuf)),
  86                 tests.MaxMsgSize).Return(mbuf, errors.New("test failure"))
  87
  88         writer := httptest.NewRecorder()
  89
  90         handleRequest(writer, log, rmrMessengerMock, tests.GetInvalidRequestDetails(), x2SetupMessageType)
  91         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
  92 }
  93
  94 func TestHandleRequestFailure_InvalidMessageType(t *testing.T) {
  95         log, err := logger.InitLogger(logger.InfoLevel)
  96         if err != nil {
  97                 t.Errorf("#nodeb_controller_test.TestHandleRequestFailure - failed to initialize logger, error: %s", err)
  98         }
  99
 100         rmrMessengerMock := &mocks.RmrMessengerMock{}
 101         var mbuf *rmrCgo.MBuf
 102
 103         rmrMessengerMock.On("SendMsg",
 104                 mock.AnythingOfType(fmt.Sprintf("%T", mbuf)),
 105                 tests.MaxMsgSize).Return(mbuf, errors.New("test failure"))
 106
 107         writer := httptest.NewRecorder()
 108
 109         handleRequest(writer, log, rmrMessengerMock, tests.GetInvalidMessageType(), "dummy")
 110         assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
 111 }
 112
 113 func TestHandleHealthCheckRequest(t *testing.T) {
 114         rc := NewNodebController(nil, nil, nil, nil)
 115         writer := httptest.NewRecorder()
 116         rc.HandleHealthCheckRequest(writer, nil)
 117         assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
 118 }
 119
 120 func handleRequest(writer *httptest.ResponseRecorder, log *logger.Logger, rmrMessengerMock *mocks.RmrMessengerMock,
 121         request *http.Request, messageType string) {
 122         rmrService := getRmrService(rmrMessengerMock, log)
 123         request = mux.SetURLVars(request, map[string]string{"messageType": messageType})
 124
 125         var nodebInfo *entities.NodebInfo
 126         var nbIdentity *entities.NbIdentity
 127
 128         rnibWriterMock := mocks.RnibWriterMock{}
 129         rnibWriterMock.On("SaveNodeb",
 130                 mock.AnythingOfType(fmt.Sprintf("%T", nbIdentity)),
 131                 mock.AnythingOfType(fmt.Sprintf("%T", nodebInfo))).Return(nil)
 132
 133         rnibReaderProvider := func() reader.RNibReader {
 134                 return &mocks.RnibReaderMock{}
 135         }
 136
 137         rnibWriterProvider := func() rNibWriter.RNibWriter {
 138                 return &rnibWriterMock
 139         }
 140
 141         NewNodebController(log, rmrService, rnibReaderProvider, rnibWriterProvider).HandleRequest(writer, request)
 142 }
 143
 144 func getRmrService(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *services.RmrService {
 145         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
 146         messageChannel := make(chan *models.NotificationResponse)
 147         rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
 148         return services.NewRmrService(services.NewRmrConfig(tests.Port, tests.MaxMsgSize, tests.Flags, log), rmrMessenger, make(sessions.E2Sessions), messageChannel)
 149 }
 150
 151 func executeGetNodeb(logger *logger.Logger, writer *httptest.ResponseRecorder, rnibReaderProvider func() reader.RNibReader) {
 152         req, _ := http.NewRequest("GET", "/nodeb", nil)
 153         req = mux.SetURLVars(req, map[string]string{"ranName": "testNode"})
 154
 155         NewNodebController(logger, nil, rnibReaderProvider, nil).GetNodeb(writer, req)
 156 }
 157
 158 func TestNodebController_GetNodeb_Success(t *testing.T) {
 159         log, err := logger.InitLogger(logger.InfoLevel)
 160
 161         if err != nil {
 162                 t.Errorf("#nodeb_controller_test.TestNodebController_GetNodeb_Success - failed to initialize logger, error: %s", err)
 163         }
 164
 165         writer := httptest.NewRecorder()
 166
 167         rnibReaderMock := mocks.RnibReaderMock{}
 168
 169         var rnibError error
 170         rnibReaderMock.On("GetNodeb", "testNode").Return(&entities.NodebInfo{}, rnibError)
 171
 172         rnibReaderProvider := func() reader.RNibReader {
 173                 return &rnibReaderMock
 174         }
 175
 176         executeGetNodeb(log, writer, rnibReaderProvider)
 177
 178         assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
 179 }
 180
 181 func TestNodebController_GetNodeb_NotFound(t *testing.T) {
 182         log, err := logger.InitLogger(logger.InfoLevel)
 183
 184         if err != nil {
 185                 t.Errorf("#nodeb_controller_test.TestNodebController_GetNodeb_NotFound - failed to initialize logger, error: %s", err)
 186         }
 187
 188         writer := httptest.NewRecorder()
 189
 190         rnibReaderMock := mocks.RnibReaderMock{}
 191         rnibError := common.NewResourceNotFoundErrorf("#reader.GetNodeb - responding node %s not found", "testNode")
 192         var nodebInfo *entities.NodebInfo
 193         rnibReaderMock.On("GetNodeb", "testNode").Return(nodebInfo, rnibError)
 194
 195         rnibReaderProvider := func() reader.RNibReader {
 196                 return &rnibReaderMock
 197         }
 198
 199         executeGetNodeb(log, writer, rnibReaderProvider)
 200         assert.Equal(t, writer.Result().StatusCode, http.StatusNotFound)
 201 }
 202
 203 func TestNodebController_GetNodeb_InternalError(t *testing.T) {
 204         log, err := logger.InitLogger(logger.InfoLevel)
 205
 206         if err != nil {
 207                 t.Errorf("#nodeb_controller_test.TestNodebController_GetNodeb_InternalError - failed to initialize logger, error: %s", err)
 208         }
 209
 210         writer := httptest.NewRecorder()
 211
 212         rnibReaderMock := mocks.RnibReaderMock{}
 213
 214         rnibError := common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error"))
 215         var nodebInfo *entities.NodebInfo
 216         rnibReaderMock.On("GetNodeb", "testNode").Return(nodebInfo, rnibError)
 217
 218         rnibReaderProvider := func() reader.RNibReader {
 219                 return &rnibReaderMock
 220         }
 221
 222         executeGetNodeb(log, writer, rnibReaderProvider)
 223         assert.Equal(t, writer.Result().StatusCode, http.StatusInternalServerError)
 224 }
 225
 226 func executeGetNodebIdList(logger *logger.Logger, writer *httptest.ResponseRecorder, rnibReaderProvider func() reader.RNibReader) {
 227         req, _ := http.NewRequest("GET", "/nodeb-ids", nil)
 228         NewNodebController(logger, nil, rnibReaderProvider, nil ).GetNodebIdList(writer,req)
 229 }
 230
 231 func TestNodebController_GetNodebIdList_Success(t *testing.T) {
 232         logger, err := logger.InitLogger(logger.InfoLevel)
 233
 234         if err != nil {
 235                 t.Errorf("#nodeb_controller_test.TestNodebController_GetNodebIdList_Success - failed to initialize logger, error: %s", err)
 236         }
 237
 238         writer := httptest.NewRecorder()
 239
 240         rnibReaderMock := mocks.RnibReaderMock{}
 241         var rnibError error
 242
 243         nbList := []*entities.NbIdentity{
 244                 {InventoryName:"test1", GlobalNbId: &entities.GlobalNbId{PlmnId:"plmnId1",NbId: "nbId1"}},
 245                 {InventoryName:"test2", GlobalNbId: &entities.GlobalNbId{PlmnId:"plmnId2",NbId: "nbId2"}},
 246                 {InventoryName:"test3", GlobalNbId: &entities.GlobalNbId{PlmnId:"",NbId: ""}},
 247         }
 248         rnibReaderMock.On("GetListNodebIds").Return(nbList, rnibError)
 249
 250         rnibReaderProvider := func() reader.RNibReader {
 251                 return &rnibReaderMock
 252         }
 253
 254         executeGetNodebIdList(logger, writer, rnibReaderProvider)
 255         assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
 256         bodyBytes, err := ioutil.ReadAll(writer.Body)
 257         assert.Equal(t, "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}},{\"inventoryName\":\"test3\",\"globalNbId\":{}}]",string(bodyBytes) )
 258 }
 259
 260 func TestNodebController_GetNodebIdList_EmptyList(t *testing.T) {
 261         log, err := logger.InitLogger(logger.InfoLevel)
 262
 263         if err != nil {
 264                 t.Errorf("#nodeb_controller_test.TestNodebController_GetNodebIdList_EmptyList - failed to initialize logger, error: %s", err)
 265         }
 266
 267         writer := httptest.NewRecorder()
 268
 269         rnibReaderMock := mocks.RnibReaderMock{}
 270
 271         var rnibError error
 272         nbList := []*entities.NbIdentity{}
 273         rnibReaderMock.On("GetListNodebIds").Return(nbList, rnibError)
 274
 275
 276         rnibReaderProvider := func() reader.RNibReader {
 277                 return &rnibReaderMock
 278         }
 279
 280         executeGetNodebIdList(log, writer, rnibReaderProvider)
 281
 282         assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
 283         bodyBytes, err := ioutil.ReadAll(writer.Body)
 284         assert.Equal(t, "[]", string(bodyBytes))
 285 }
 286
 287 func TestNodebController_GetNodebIdList_InternalError(t *testing.T) {
 288         logger, err := logger.InitLogger(logger.InfoLevel)
 289
 290         if err != nil {
 291                 t.Errorf("#nodeb_controller_test.TestNodebController_GetNodebIdList_InternalError - failed to initialize logger, error: %s", err)
 292         }
 293
 294         writer := httptest.NewRecorder()
 295
 296         rnibReaderMock := mocks.RnibReaderMock{}
 297
 298         rnibError := common.NewInternalError(errors.New("#reader.GetEnbIdList - Internal Error"))
 299         var nbList []*entities.NbIdentity
 300         rnibReaderMock.On("GetListNodebIds").Return(nbList, rnibError)
 301
 302         rnibReaderProvider := func() reader.RNibReader {
 303                 return &rnibReaderMock
 304         }
 305
 306         executeGetNodebIdList(logger, writer, rnibReaderProvider)
 307         assert.Equal(t, writer.Result().StatusCode, http.StatusInternalServerError)
 308 }