RSM/controllers/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 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
  18 //  platform project (RICP).
  19
  20
  21 package controllers
  22
  23 import (
  24         "encoding/json"
  25         "fmt"
  26         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  27         "github.com/stretchr/testify/assert"
  28         "github.com/stretchr/testify/mock"
  29         "io"
  30         "io/ioutil"
  31         "net/http"
  32         "net/http/httptest"
  33         "rsm/configuration"
  34         "rsm/enums"
  35         "rsm/logger"
  36         "rsm/mocks"
  37         "rsm/models"
  38         "rsm/providers/httpmsghandlerprovider"
  39         "rsm/rsmerrors"
  40         "rsm/services"
  41         "rsm/tests"
  42         "strings"
  43         "testing"
  44 )
  45
  46 func setupControllerTest(t *testing.T) (*Controller, *mocks.RnibReaderMock, *mocks.RsmReaderMock, *mocks.RsmWriterMock, *mocks.ResourceStatusServiceMock) {
  47         log, err := logger.InitLogger(logger.DebugLevel)
  48         if err != nil {
  49                 t.Errorf("#... - failed to initialize logger, error: %s", err)
  50         }
  51
  52         config, err := configuration.ParseConfiguration()
  53         if err != nil {
  54                 t.Errorf("#... - failed to parse configuration error: %s", err)
  55         }
  56
  57         resourceStatusServiceMock := &mocks.ResourceStatusServiceMock{}
  58         rnibReaderMock := &mocks.RnibReaderMock{}
  59         rsmReaderMock := &mocks.RsmReaderMock{}
  60         rsmWriterMock := &mocks.RsmWriterMock{}
  61
  62         rnibDataService := services.NewRnibDataService(log, config, rnibReaderMock, rsmReaderMock, rsmWriterMock)
  63         handlerProvider := httpmsghandlerprovider.NewRequestHandlerProvider(log, rnibDataService, resourceStatusServiceMock)
  64         controller := NewController(log, handlerProvider)
  65         return controller, rnibReaderMock, rsmReaderMock, rsmWriterMock, resourceStatusServiceMock
  66 }
  67
  68 func TestResourceStatusInvalidBody(t *testing.T) {
  69         controller, _, _, _ , _:= setupControllerTest(t)
  70
  71         header := http.Header{}
  72         header.Set("Content-Type", "application/json")
  73         httpRequest, _ := http.NewRequest("PUT", "http://localhost:4800/v1/general/resourcestatus", strings.NewReader("{}{}"))
  74         httpRequest.Header = header
  75
  76         writer := httptest.NewRecorder()
  77         controller.ResourceStatus(writer, httpRequest)
  78
  79         var errorResponse = parseJsonRequest(t, writer.Body)
  80
  81         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
  82         assert.Equal(t, rsmerrors.NewInvalidJsonError().Code, errorResponse.Code)
  83 }
  84
  85 func TestResourceStatusSuccess(t *testing.T) {
  86         controller, readerMock, rsmReaderMock, rsmWriterMock,  resourceStatusServiceMock := setupControllerTest(t)
  87
  88         cellId1 := "02f829:0007ab00"
  89         cellId2 := "02f829:0007ab50"
  90         nodebInfo := &entities.NodebInfo{
  91                 RanName:         tests.RanName,
  92                 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
  93                 Configuration: &entities.NodebInfo_Enb{
  94                         Enb: &entities.Enb{
  95                                 ServedCells: []*entities.ServedCellInfo{{CellId: cellId1}, {CellId: cellId2}},
  96                         },
  97                 },
  98         }
  99         var nbIdentityList []*entities.NbIdentity
 100         config := tests.GetRsmGeneralConfiguration(true)
 101
 102         rsmWriterMock.On("SaveRsmGeneralConfiguration", config).Return(nil)
 103         rsmReaderMock.On("GetRsmGeneralConfiguration").Return(config, nil)
 104         readerMock.On("GetListEnbIds").Return(nbIdentityList, nil)
 105         readerMock.On("GetNodeb", tests.RanName).Return(nodebInfo)
 106         resourceStatusServiceMock.On("BuildAndSendInitiateRequest", mock.AnythingOfType("*entities.NodebInfo"), mock.AnythingOfType("*models.RsmGeneralConfiguration"), enums.Enb1MeasurementId).Return(nil)
 107
 108         header := http.Header{}
 109         header.Set("Content-Type", "application/json")
 110         httpRequest, _ := http.NewRequest("PUT", "http://localhost:4800/v1/general/resourcestatus", strings.NewReader("{\"enableResourceStatus\":true}"))
 111         httpRequest.Header = header
 112
 113         writer := httptest.NewRecorder()
 114         controller.ResourceStatus(writer, httpRequest)
 115
 116         readerMock.AssertNumberOfCalls(t, "GetListEnbIds", 1)
 117         resourceStatusServiceMock.AssertNumberOfCalls(t, "BuildAndSendInitiateRequest", 0)
 118
 119         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 120 }
 121
 122 func TestResourceStatusFail(t *testing.T) {
 123
 124         controller, readerMock, rsmReaderMock, _,  resourceStatusServiceMock := setupControllerTest(t)
 125
 126         rnibErr := &rsmerrors.RnibDbError{}
 127
 128         rsmReaderMock.On("GetRsmGeneralConfiguration").Return(tests.GetRsmGeneralConfiguration(true), rnibErr)
 129
 130         header := http.Header{}
 131         header.Set("Content-Type", "application/json")
 132         httpRequest, _ := http.NewRequest("PUT", "http://localhost:4800/v1/general/resourcestatus", strings.NewReader("{\"enableResourceStatus\":true}"))
 133         httpRequest.Header = header
 134
 135         writer := httptest.NewRecorder()
 136         controller.ResourceStatus(writer, httpRequest)
 137
 138         readerMock.AssertNumberOfCalls(t, "GetListEnbIds", 0)
 139         resourceStatusServiceMock.AssertNumberOfCalls(t, "BuildAndSendInitiateRequest", 0)
 140
 141         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 142 }
 143
 144 func TestHeaderValidationFailed(t *testing.T) {
 145         controller, _, _ ,_ , _:= setupControllerTest(t)
 146
 147         writer := httptest.NewRecorder()
 148         header := &http.Header{}
 149         controller.handleRequest(writer, header, "", nil, true)
 150         var errorResponse = parseJsonRequest(t, writer.Body)
 151         err := rsmerrors.NewHeaderValidationError()
 152
 153         assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
 154         assert.Equal(t, errorResponse.Code, err.Code)
 155         assert.Equal(t, errorResponse.Message, err.Message)
 156 }
 157
 158 func TestHandleInternalError(t *testing.T) {
 159         controller, _, _,_ ,_ := setupControllerTest(t)
 160
 161         writer := httptest.NewRecorder()
 162         err := rsmerrors.NewInternalError()
 163
 164         controller.handleErrorResponse(err, writer)
 165         var errorResponse = parseJsonRequest(t, writer.Body)
 166
 167         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 168         assert.Equal(t, errorResponse.Code, err.Code)
 169         assert.Equal(t, errorResponse.Message, err.Message)
 170 }
 171
 172 func TestValidateHeadersSuccess(t *testing.T) {
 173         controller, _, _,_ ,_ := setupControllerTest(t)
 174
 175         header := http.Header{}
 176         header.Set("Content-Type", "application/json")
 177         result := controller.validateRequestHeader(&header)
 178
 179         assert.Nil(t, result)
 180 }
 181
 182 func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
 183
 184         var errorResponse models.ErrorResponse
 185         body, err := ioutil.ReadAll(r)
 186         if err != nil {
 187                 t.Errorf("Error cannot deserialize json request")
 188         }
 189         json.Unmarshal(body, &errorResponse)
 190
 191         return errorResponse
 192 }
 193
 194 func TestHandleErrorResponse(t *testing.T) {
 195         controller, _, _ ,_ , _:= setupControllerTest(t)
 196
 197         writer := httptest.NewRecorder()
 198         controller.handleErrorResponse(rsmerrors.NewRnibDbError(), writer)
 199         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 200
 201         writer = httptest.NewRecorder()
 202         controller.handleErrorResponse(rsmerrors.NewHeaderValidationError(), writer)
 203         assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
 204
 205         writer = httptest.NewRecorder()
 206         controller.handleErrorResponse(rsmerrors.NewWrongStateError("", ""), writer)
 207         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 208
 209         writer = httptest.NewRecorder()
 210         controller.handleErrorResponse(rsmerrors.NewRequestValidationError(), writer)
 211         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 212
 213         writer = httptest.NewRecorder()
 214         controller.handleErrorResponse(rsmerrors.NewRmrError(), writer)
 215         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 216
 217         writer = httptest.NewRecorder()
 218         controller.handleErrorResponse(rsmerrors.NewResourceNotFoundError(), writer)
 219         assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
 220
 221         writer = httptest.NewRecorder()
 222         controller.handleErrorResponse(rsmerrors.NewInvalidJsonError(), writer)
 223         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 224
 225         writer = httptest.NewRecorder()
 226         controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
 227         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 228
 229         writer = httptest.NewRecorder()
 230         controller.handleErrorResponse(rsmerrors.NewRsmError(2), writer)
 231         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 232 }