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/julienschmidt/httprouter"
  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, writer.Result().StatusCode, http.StatusOK)
  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, 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         params := []httprouter.Param{{Key: "messageType", Value: 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, params)
 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
 152 func executeGetNodeb(logger *logger.Logger, writer *httptest.ResponseRecorder, rnibReaderProvider func() reader.RNibReader) {
 153         req, _ := http.NewRequest("GET", "/nodeb", nil)
 154
 155         params := []httprouter.Param{{Key: "ranName", Value: "testNode"}}
 156
 157         NewNodebController(logger, nil, rnibReaderProvider, nil).GetNodeb(writer, req, params)
 158 }
 159
 160 func TestNodebController_GetNodeb_Success(t *testing.T) {
 161         log, err := logger.InitLogger(logger.InfoLevel)
 162
 163         if err != nil {
 164                 t.Errorf("#nodeb_controller_test.TestNodebController_GetNodeb_Success - failed to initialize logger, error: %s", err)
 165         }
 166
 167         writer := httptest.NewRecorder()
 168
 169         rnibReaderMock := mocks.RnibReaderMock{}
 170
 171         var rnibError common.IRNibError
 172         rnibReaderMock.On("GetNodeb", "testNode").Return(&entities.NodebInfo{}, rnibError)
 173
 174         rnibReaderProvider := func() reader.RNibReader {
 175                 return &rnibReaderMock
 176         }
 177
 178         executeGetNodeb(log, writer, rnibReaderProvider)
 179
 180         assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
 181 }
 182
 183 func TestNodebController_GetNodeb_NotFound(t *testing.T) {
 184         log, err := logger.InitLogger(logger.InfoLevel)
 185
 186         if err != nil {
 187                 t.Errorf("#nodeb_controller_test.TestNodebController_GetNodeb_NotFound - failed to initialize logger, error: %s", err)
 188         }
 189
 190         writer := httptest.NewRecorder()
 191
 192         rnibReaderMock := mocks.RnibReaderMock{}
 193         rnibError := common.NewResourceNotFoundError(errors.Errorf("#reader.GetNodeb - responding node %s not found", "testNode"))
 194         var nodebInfo *entities.NodebInfo
 195         rnibReaderMock.On("GetNodeb", "testNode").Return(nodebInfo, rnibError)
 196
 197         rnibReaderProvider := func() reader.RNibReader {
 198                 return &rnibReaderMock
 199         }
 200
 201         executeGetNodeb(log, writer, rnibReaderProvider)
 202         assert.Equal(t, writer.Result().StatusCode, http.StatusNotFound)
 203 }
 204
 205 func TestNodebController_GetNodeb_InternalError(t *testing.T) {
 206         log, err := logger.InitLogger(logger.InfoLevel)
 207
 208         if err != nil {
 209                 t.Errorf("#nodeb_controller_test.TestNodebController_GetNodeb_InternalError - failed to initialize logger, error: %s", err)
 210         }
 211
 212         writer := httptest.NewRecorder()
 213
 214         rnibReaderMock := mocks.RnibReaderMock{}
 215
 216         rnibError := common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error"))
 217         var nodebInfo *entities.NodebInfo
 218         rnibReaderMock.On("GetNodeb", "testNode").Return(nodebInfo, rnibError)
 219
 220         rnibReaderProvider := func() reader.RNibReader {
 221                 return &rnibReaderMock
 222         }
 223
 224         executeGetNodeb(log, writer, rnibReaderProvider)
 225         assert.Equal(t, writer.Result().StatusCode, http.StatusInternalServerError)
 226 }
 227
 228 func executeGetNodebIdList(logger *logger.Logger, writer *httptest.ResponseRecorder, rnibReaderProvider func() reader.RNibReader) {
 229         req, _ := http.NewRequest("GET", "/nodeb-ids", nil)
 230         NewNodebController(logger, nil, rnibReaderProvider, nil ).GetNodebIdList(writer,req,nil)
 231 }
 232
 233 func TestNodebController_GetNodebIdList_Success(t *testing.T) {
 234         logger, err := logger.InitLogger(logger.InfoLevel)
 235
 236         if err!=nil{
 237                 t.Errorf("#nodeb_controller_test.TestNodebController_GetNodebIdList_Success - failed to initialize logger, error: %s", err)
 238         }
 239
 240         writer := httptest.NewRecorder()
 241
 242         rnibReaderMock := mocks.RnibReaderMock{}
 243         var rnibError common.IRNibError
 244
 245         enbList := []*entities.NbIdentity{&entities.NbIdentity{InventoryName:"test1", GlobalNbId: &entities.GlobalNbId{PlmnId:"plmnId1",NbId: "nbId1"}}}
 246         gnbList := []*entities.NbIdentity{&entities.NbIdentity{InventoryName:"test2", GlobalNbId: &entities.GlobalNbId{PlmnId:"plmnId2",NbId: "nbId2"}}}
 247
 248         rnibReaderMock.On("GetListEnbIds").Return(&enbList, rnibError)
 249         rnibReaderMock.On("GetListGnbIds").Return(&gnbList, rnibError)
 250
 251
 252         rnibReaderProvider:= func() reader.RNibReader {
 253                 return &rnibReaderMock
 254         }
 255
 256         executeGetNodebIdList(logger, writer, rnibReaderProvider)
 257         assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
 258         bodyBytes, err := ioutil.ReadAll(writer.Body)
 259         assert.Equal(t, "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}}]",string(bodyBytes) )
 260 }
 261
 262 func TestNodebController_GetNodebIdList_EmptyList(t *testing.T) {
 263         log, err := logger.InitLogger(logger.InfoLevel)
 264
 265         if err!=nil{
 266                 t.Errorf("#nodeb_controller_test.TestNodebController_GetNodebIdList_EmptyList - failed to initialize logger, error: %s", err)
 267         }
 268
 269         writer := httptest.NewRecorder()
 270
 271         rnibReaderMock := mocks.RnibReaderMock{}
 272
 273         var rnibError common.IRNibError
 274         enbList := []*entities.NbIdentity{}
 275         gnbList := []*entities.NbIdentity{}
 276
 277         rnibReaderMock.On("GetListEnbIds").Return(&enbList, rnibError)
 278         rnibReaderMock.On("GetListGnbIds").Return(&gnbList, rnibError)
 279
 280
 281         rnibReaderProvider:= func() reader.RNibReader {
 282                 return &rnibReaderMock
 283         }
 284
 285         executeGetNodebIdList(log, writer, rnibReaderProvider)
 286
 287         assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
 288         bodyBytes, err := ioutil.ReadAll(writer.Body)
 289         assert.Equal(t, "[]", string(bodyBytes))
 290 }
 291
 292 func TestNodebController_GetNodebIdList_InternalError(t *testing.T) {
 293         logger, err := logger.InitLogger(logger.InfoLevel)
 294
 295         if err != nil {
 296                 t.Errorf("#nodeb_controller_test.TestNodebController_GetNodebIdList_InternalError - failed to initialize logger, error: %s", err)
 297         }
 298
 299         writer := httptest.NewRecorder()
 300
 301         rnibReaderMock := mocks.RnibReaderMock{}
 302
 303         rnibError := common.NewInternalError(errors.New("#reader.GetEnbIdList - Internal Error"))
 304         var enbList *[]*entities.NbIdentity
 305         rnibReaderMock.On("GetListEnbIds").Return(enbList, rnibError)
 306
 307         rnibReaderProvider := func() reader.RNibReader {
 308                 return &rnibReaderMock
 309         }
 310
 311         executeGetNodebIdList(logger, writer, rnibReaderProvider)
 312         assert.Equal(t, writer.Result().StatusCode, http.StatusInternalServerError)
 313 }
 314
 315 func TestNodebController_GetNodebIdList_Success_One(t *testing.T) {
 316         logger, err := logger.InitLogger(logger.InfoLevel)
 317
 318         if err!=nil{
 319                 t.Errorf("#nodeb_controller_test.TestNodebController_GetNodebIdList_Success - failed to initialize logger, error: %s", err)
 320         }
 321
 322         writer := httptest.NewRecorder()
 323
 324         rnibReaderMock := mocks.RnibReaderMock{}
 325         var rnibError common.IRNibError
 326
 327         enbList := []*entities.NbIdentity{}
 328         gnbList := []*entities.NbIdentity{&entities.NbIdentity{InventoryName:"test2", GlobalNbId: &entities.GlobalNbId{PlmnId:"plmnId2",NbId: "nbId2"}}}
 329
 330         rnibReaderMock.On("GetListEnbIds").Return(&enbList, rnibError)
 331         rnibReaderMock.On("GetListGnbIds").Return(&gnbList, rnibError)
 332
 333
 334         rnibReaderProvider:= func() reader.RNibReader {
 335                 return &rnibReaderMock
 336         }
 337
 338         executeGetNodebIdList(logger, writer, rnibReaderProvider)
 339         assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
 340         bodyBytes, err := ioutil.ReadAll(writer.Body)
 341         assert.Equal(t, "[{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}}]",string(bodyBytes) )
 342 }
 343
 344 func TestNodebController_GetNodebIdList_Success_Many(t *testing.T) {
 345         logger, err := logger.InitLogger(logger.InfoLevel)
 346
 347         if err!=nil{
 348                 t.Errorf("#nodeb_controller_test.TestNodebController_GetNodebIdList_Success - failed to initialize logger, error: %s", err)
 349         }
 350
 351         writer := httptest.NewRecorder()
 352
 353         rnibReaderMock := mocks.RnibReaderMock{}
 354         var rnibError common.IRNibError
 355
 356         enbList := []*entities.NbIdentity{&entities.NbIdentity{InventoryName:"test1", GlobalNbId: &entities.GlobalNbId{PlmnId:"plmnId1",NbId: "nbId1"}}}
 357         gnbList := []*entities.NbIdentity{&entities.NbIdentity{InventoryName:"test2", GlobalNbId: &entities.GlobalNbId{PlmnId:"plmnId2",NbId: "nbId2"}}, {InventoryName:"test3", GlobalNbId: &entities.GlobalNbId{PlmnId:"plmnId3",NbId: "nbId3"}}}
 358
 359         rnibReaderMock.On("GetListEnbIds").Return(&enbList, rnibError)
 360         rnibReaderMock.On("GetListGnbIds").Return(&gnbList, rnibError)
 361
 362
 363         rnibReaderProvider:= func() reader.RNibReader {
 364                 return &rnibReaderMock
 365         }
 366
 367         executeGetNodebIdList(logger, writer, rnibReaderProvider)
 368         assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
 369         bodyBytes, err := ioutil.ReadAll(writer.Body)
 370         assert.Equal(t, "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}},{\"inventoryName\":\"test3\",\"globalNbId\":{\"plmnId\":\"plmnId3\",\"nbId\":\"nbId3\"}}]",string(bodyBytes) )
 371 }