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         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  30         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  31         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
  32         "github.com/gorilla/mux"
  33         "github.com/pkg/errors"
  34         "github.com/stretchr/testify/assert"
  35         "io/ioutil"
  36         "net/http"
  37         "net/http/httptest"
  38         "testing"
  39 )
  40
  41 func TestNewRequestController(t *testing.T) {
  42         rnibReaderProvider := func() reader.RNibReader {
  43                 return &mocks.RnibReaderMock{}
  44         }
  45         rnibWriterProvider := func() rNibWriter.RNibWriter {
  46                 return &mocks.RnibWriterMock{}
  47         }
  48
  49         assert.NotNil(t, NewNodebController(&logger.Logger{}, &services.RmrService{}, rnibReaderProvider, rnibWriterProvider))
  50 }
  51
  52 func TestHandleHealthCheckRequest(t *testing.T) {
  53         rc := NewNodebController(nil, nil, nil, nil)
  54         writer := httptest.NewRecorder()
  55         rc.HandleHealthCheckRequest(writer, nil)
  56         assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
  57 }
  58
  59 func getRmrService(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *services.RmrService {
  60         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
  61         messageChannel := make(chan *models.NotificationResponse)
  62         rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
  63         return services.NewRmrService(services.NewRmrConfig(tests.Port, tests.MaxMsgSize, tests.Flags, log), rmrMessenger, make(sessions.E2Sessions), messageChannel)
  64 }
  65
  66 func executeGetNodeb(logger *logger.Logger, writer *httptest.ResponseRecorder, rnibReaderProvider func() reader.RNibReader) {
  67         req, _ := http.NewRequest("GET", "/nodeb", nil)
  68         req = mux.SetURLVars(req, map[string]string{"ranName": "testNode"})
  69
  70         NewNodebController(logger, nil, rnibReaderProvider, nil).GetNodeb(writer, req)
  71 }
  72
  73 func TestNodebController_GetNodeb_Success(t *testing.T) {
  74         log, err := logger.InitLogger(logger.InfoLevel)
  75
  76         if err != nil {
  77                 t.Errorf("#nodeb_controller_test.TestNodebController_GetNodeb_Success - failed to initialize logger, error: %s", err)
  78         }
  79
  80         writer := httptest.NewRecorder()
  81
  82         rnibReaderMock := mocks.RnibReaderMock{}
  83
  84         var rnibError error
  85         rnibReaderMock.On("GetNodeb", "testNode").Return(&entities.NodebInfo{}, rnibError)
  86
  87         rnibReaderProvider := func() reader.RNibReader {
  88                 return &rnibReaderMock
  89         }
  90
  91         executeGetNodeb(log, writer, rnibReaderProvider)
  92
  93         assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
  94 }
  95
  96 func TestNodebController_GetNodeb_NotFound(t *testing.T) {
  97         log, err := logger.InitLogger(logger.InfoLevel)
  98
  99         if err != nil {
 100                 t.Errorf("#nodeb_controller_test.TestNodebController_GetNodeb_NotFound - failed to initialize logger, error: %s", err)
 101         }
 102
 103         writer := httptest.NewRecorder()
 104
 105         rnibReaderMock := mocks.RnibReaderMock{}
 106         rnibError := common.NewResourceNotFoundErrorf("#reader.GetNodeb - responding node %s not found", "testNode")
 107         var nodebInfo *entities.NodebInfo
 108         rnibReaderMock.On("GetNodeb", "testNode").Return(nodebInfo, rnibError)
 109
 110         rnibReaderProvider := func() reader.RNibReader {
 111                 return &rnibReaderMock
 112         }
 113
 114         executeGetNodeb(log, writer, rnibReaderProvider)
 115         assert.Equal(t, writer.Result().StatusCode, http.StatusNotFound)
 116 }
 117
 118 func TestNodebController_GetNodeb_InternalError(t *testing.T) {
 119         log, err := logger.InitLogger(logger.InfoLevel)
 120
 121         if err != nil {
 122                 t.Errorf("#nodeb_controller_test.TestNodebController_GetNodeb_InternalError - failed to initialize logger, error: %s", err)
 123         }
 124
 125         writer := httptest.NewRecorder()
 126
 127         rnibReaderMock := mocks.RnibReaderMock{}
 128
 129         rnibError := common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error"))
 130         var nodebInfo *entities.NodebInfo
 131         rnibReaderMock.On("GetNodeb", "testNode").Return(nodebInfo, rnibError)
 132
 133         rnibReaderProvider := func() reader.RNibReader {
 134                 return &rnibReaderMock
 135         }
 136
 137         executeGetNodeb(log, writer, rnibReaderProvider)
 138         assert.Equal(t, writer.Result().StatusCode, http.StatusInternalServerError)
 139 }
 140
 141 func executeGetNodebIdList(logger *logger.Logger, writer *httptest.ResponseRecorder, rnibReaderProvider func() reader.RNibReader) {
 142         req, _ := http.NewRequest("GET", "/nodeb-ids", nil)
 143         NewNodebController(logger, nil, rnibReaderProvider, nil ).GetNodebIdList(writer,req)
 144 }
 145
 146 func TestNodebController_GetNodebIdList_Success(t *testing.T) {
 147         logger, err := logger.InitLogger(logger.InfoLevel)
 148
 149         if err != nil {
 150                 t.Errorf("#nodeb_controller_test.TestNodebController_GetNodebIdList_Success - failed to initialize logger, error: %s", err)
 151         }
 152
 153         writer := httptest.NewRecorder()
 154
 155         rnibReaderMock := mocks.RnibReaderMock{}
 156         var rnibError error
 157
 158         nbList := []*entities.NbIdentity{
 159                 {InventoryName:"test1", GlobalNbId: &entities.GlobalNbId{PlmnId:"plmnId1",NbId: "nbId1"}},
 160                 {InventoryName:"test2", GlobalNbId: &entities.GlobalNbId{PlmnId:"plmnId2",NbId: "nbId2"}},
 161                 {InventoryName:"test3", GlobalNbId: &entities.GlobalNbId{PlmnId:"",NbId: ""}},
 162         }
 163         rnibReaderMock.On("GetListNodebIds").Return(nbList, rnibError)
 164
 165         rnibReaderProvider := func() reader.RNibReader {
 166                 return &rnibReaderMock
 167         }
 168
 169         executeGetNodebIdList(logger, writer, rnibReaderProvider)
 170         assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
 171         bodyBytes, err := ioutil.ReadAll(writer.Body)
 172         assert.Equal(t, "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}},{\"inventoryName\":\"test3\",\"globalNbId\":{}}]",string(bodyBytes) )
 173 }
 174
 175 func TestNodebController_GetNodebIdList_EmptyList(t *testing.T) {
 176         log, err := logger.InitLogger(logger.InfoLevel)
 177
 178         if err != nil {
 179                 t.Errorf("#nodeb_controller_test.TestNodebController_GetNodebIdList_EmptyList - failed to initialize logger, error: %s", err)
 180         }
 181
 182         writer := httptest.NewRecorder()
 183
 184         rnibReaderMock := mocks.RnibReaderMock{}
 185
 186         var rnibError error
 187         nbList := []*entities.NbIdentity{}
 188         rnibReaderMock.On("GetListNodebIds").Return(nbList, rnibError)
 189
 190
 191         rnibReaderProvider := func() reader.RNibReader {
 192                 return &rnibReaderMock
 193         }
 194
 195         executeGetNodebIdList(log, writer, rnibReaderProvider)
 196
 197         assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
 198         bodyBytes, err := ioutil.ReadAll(writer.Body)
 199         assert.Equal(t, "[]", string(bodyBytes))
 200 }
 201
 202 func TestNodebController_GetNodebIdList_InternalError(t *testing.T) {
 203         logger, err := logger.InitLogger(logger.InfoLevel)
 204
 205         if err != nil {
 206                 t.Errorf("#nodeb_controller_test.TestNodebController_GetNodebIdList_InternalError - failed to initialize logger, error: %s", err)
 207         }
 208
 209         writer := httptest.NewRecorder()
 210
 211         rnibReaderMock := mocks.RnibReaderMock{}
 212
 213         rnibError := common.NewInternalError(errors.New("#reader.GetEnbIdList - Internal Error"))
 214         var nbList []*entities.NbIdentity
 215         rnibReaderMock.On("GetListNodebIds").Return(nbList, rnibError)
 216
 217         rnibReaderProvider := func() reader.RNibReader {
 218                 return &rnibReaderMock
 219         }
 220
 221         executeGetNodebIdList(logger, writer, rnibReaderProvider)
 222         assert.Equal(t, writer.Result().StatusCode, http.StatusInternalServerError)
 223 }