E2Manager/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
  18 package controllers
  19
  20 import (
  21         "e2mgr/configuration"
  22         "e2mgr/e2managererrors"
  23         "e2mgr/logger"
  24         "e2mgr/mocks"
  25         "e2mgr/models"
  26         "e2mgr/providers"
  27         "e2mgr/rNibWriter"
  28         "e2mgr/tests"
  29         "encoding/json"
  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/stretchr/testify/assert"
  34         "io"
  35         "io/ioutil"
  36         "net/http"
  37         "net/http/httptest"
  38         "testing"
  39 )
  40
  41 func TestShutdownHandlerRnibError(t *testing.T) {
  42         log := initLog(t)
  43         config := configuration.ParseConfiguration()
  44
  45         rmrMessengerMock := &mocks.RmrMessengerMock{}
  46         readerMock := &mocks.RnibReaderMock{}
  47         readerProvider := func() reader.RNibReader {
  48                 return readerMock
  49         }
  50         writerMock := &mocks.RnibWriterMock{}
  51         writerProvider := func() rNibWriter.RNibWriter {
  52                 return writerMock
  53         }
  54         var messageChannel chan<- *models.NotificationResponse
  55
  56         rnibErr := &common.RNibError{}
  57         var nbIdentityList []*entities.NbIdentity
  58         readerMock.On("GetListNodebIds").Return(nbIdentityList, rnibErr)
  59
  60         writer := httptest.NewRecorder()
  61         controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config, messageChannel)
  62         controller.ShutdownHandler(writer, tests.GetHttpRequest(), nil)
  63
  64         var errorResponse = parseJsonRequest(t, writer.Body)
  65
  66         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
  67         assert.Equal(t, errorResponse.Code, e2managererrors.NewRnibDbError().Err.Code)
  68 }
  69
  70 func TestHeaderValidationFailed(t *testing.T) {
  71         log := initLog(t)
  72         config := configuration.ParseConfiguration()
  73
  74         rmrMessengerMock := &mocks.RmrMessengerMock{}
  75         readerMock := &mocks.RnibReaderMock{}
  76         readerProvider := func() reader.RNibReader {
  77                 return readerMock
  78         }
  79         writerMock := &mocks.RnibWriterMock{}
  80         writerProvider := func() rNibWriter.RNibWriter {
  81                 return writerMock
  82         }
  83         var messageChannel chan<- *models.NotificationResponse
  84
  85         writer := httptest.NewRecorder()
  86
  87         controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config, messageChannel)
  88
  89         header := &http.Header{}
  90
  91         controller.handleRequest(writer, header, providers.ShutdownRequest, nil, true, http.StatusNoContent)
  92
  93         var errorResponse = parseJsonRequest(t, writer.Body)
  94         err := e2managererrors.NewHeaderValidationError()
  95
  96         assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
  97         assert.Equal(t, errorResponse.Code, err.Err.Code)
  98         assert.Equal(t, errorResponse.Message, err.Err.Message)
  99 }
 100
 101 func TestShutdownStatusNoContent(t *testing.T){
 102         log := initLog(t)
 103
 104         rmrMessengerMock := &mocks.RmrMessengerMock{}
 105         readerMock := &mocks.RnibReaderMock{}
 106         readerProvider := func() reader.RNibReader {
 107                 return readerMock
 108         }
 109         writerMock := &mocks.RnibWriterMock{}
 110         writerProvider := func() rNibWriter.RNibWriter {
 111                 return writerMock
 112         }
 113         config := configuration.ParseConfiguration()
 114         var messageChannel chan<- *models.NotificationResponse
 115
 116         var rnibError common.IRNibError
 117         nbIdentityList := []*entities.NbIdentity{}
 118         readerMock.On("GetListNodebIds").Return(nbIdentityList, rnibError)
 119
 120         writer := httptest.NewRecorder()
 121         controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config, messageChannel)
 122         controller.ShutdownHandler(writer, tests.GetHttpRequest(), nil)
 123
 124         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 125 }
 126
 127 func TestHandleInternalError(t *testing.T) {
 128         log := initLog(t)
 129         config := configuration.ParseConfiguration()
 130
 131         rmrMessengerMock := &mocks.RmrMessengerMock{}
 132         readerMock := &mocks.RnibReaderMock{}
 133         readerProvider := func() reader.RNibReader {
 134                 return readerMock
 135         }
 136         writerMock := &mocks.RnibWriterMock{}
 137         writerProvider := func() rNibWriter.RNibWriter {
 138                 return writerMock
 139         }
 140         var messageChannel chan<- *models.NotificationResponse
 141
 142         writer := httptest.NewRecorder()
 143         controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config, messageChannel)
 144         err := e2managererrors.NewInternalError()
 145
 146         controller.handleErrorResponse(err, writer)
 147         var errorResponse = parseJsonRequest(t, writer.Body)
 148
 149         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 150         assert.Equal(t, errorResponse.Code, err.Err.Code)
 151         assert.Equal(t, errorResponse.Message, err.Err.Message)
 152 }
 153
 154 func TestHandleCommandAlreadyInProgressError(t *testing.T) {
 155         log := initLog(t)
 156         config := configuration.ParseConfiguration()
 157
 158         rmrMessengerMock := &mocks.RmrMessengerMock{}
 159         readerMock := &mocks.RnibReaderMock{}
 160         readerProvider := func() reader.RNibReader {
 161                 return readerMock
 162         }
 163         writerMock := &mocks.RnibWriterMock{}
 164         writerProvider := func() rNibWriter.RNibWriter {
 165                 return writerMock
 166         }
 167         var messageChannel chan<- *models.NotificationResponse
 168         writer := httptest.NewRecorder()
 169         controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config, messageChannel)
 170         err := e2managererrors.NewCommandAlreadyInProgressError()
 171
 172         controller.handleErrorResponse(err, writer)
 173         var errorResponse = parseJsonRequest(t, writer.Body)
 174
 175         assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
 176         assert.Equal(t, errorResponse.Code, err.Err.Code)
 177         assert.Equal(t, errorResponse.Message, err.Err.Message)
 178 }
 179
 180 func TestValidateHeaders(t *testing.T){
 181         log := initLog(t)
 182
 183         rmrMessengerMock := &mocks.RmrMessengerMock{}
 184         readerMock := &mocks.RnibReaderMock{}
 185         readerProvider := func() reader.RNibReader {
 186                 return readerMock
 187         }
 188         writerMock := &mocks.RnibWriterMock{}
 189         writerProvider := func() rNibWriter.RNibWriter {
 190                 return writerMock
 191         }
 192         config := configuration.ParseConfiguration()
 193         var messageChannel chan<- *models.NotificationResponse
 194
 195         controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config, messageChannel)
 196
 197         header := http.Header{}
 198         header.Set("Content-Type", "application/json")
 199         result := controller.validateRequestHeader(&header)
 200
 201         assert.Nil(t, result)
 202 }
 203
 204 func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
 205
 206         var errorResponse models.ErrorResponse
 207         body, err := ioutil.ReadAll(r)
 208         if err != nil {
 209                 t.Errorf("Error cannot deserialize json request")
 210         }
 211         json.Unmarshal(body, &errorResponse)
 212
 213         return errorResponse
 214 }
 215
 216 func initLog(t *testing.T) *logger.Logger {
 217         log, err := logger.InitLogger(logger.InfoLevel)
 218         if err != nil {
 219                 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
 220         }
 221         return log
 222 }