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