services/src/test/java/org/onap/ccsdk/apps/services/RestExceptionHandlerTest.java

   1 package org.onap.ccsdk.apps.services;
   2
   3 import com.fasterxml.jackson.core.JsonProcessingException;
   4 import com.fasterxml.jackson.databind.ObjectMapper;
   5 import org.junit.Before;
   6 import org.junit.Test;
   7 import org.slf4j.Logger;
   8 import org.slf4j.LoggerFactory;
   9 import org.springframework.beans.ConversionNotSupportedException;
  10 import org.springframework.beans.TypeMismatchException;
  11 import org.springframework.core.MethodParameter;
  12 import org.springframework.http.HttpHeaders;
  13 import org.springframework.http.HttpStatus;
  14 import org.springframework.http.HttpStatusCode;
  15 import org.springframework.http.MediaType;
  16 import org.springframework.http.ResponseEntity;
  17 import org.springframework.http.converter.HttpMessageNotReadableException;
  18 import org.springframework.http.converter.HttpMessageNotWritableException;
  19 import org.springframework.validation.BindException;
  20 import org.springframework.web.HttpMediaTypeNotAcceptableException;
  21 import org.springframework.web.HttpMediaTypeNotSupportedException;
  22 import org.springframework.web.HttpRequestMethodNotSupportedException;
  23 import org.springframework.web.bind.MethodArgumentNotValidException;
  24 import org.springframework.web.bind.MissingPathVariableException;
  25 import org.springframework.web.bind.MissingServletRequestParameterException;
  26 import org.springframework.web.bind.ServletRequestBindingException;
  27 import org.springframework.web.context.request.WebRequest;
  28 import org.springframework.web.context.request.async.AsyncRequestTimeoutException;
  29 import org.springframework.web.multipart.support.MissingServletRequestPartException;
  30 import org.springframework.web.servlet.NoHandlerFoundException;
  31
  32 import java.util.Arrays;
  33
  34 import static org.junit.Assert.assertEquals;
  35 import static org.junit.Assert.assertTrue;
  36
  37
  38
  39 public class RestExceptionHandlerTest {
  40     private static final Logger log = LoggerFactory.getLogger("RestExceptionHandler");
  41     private class RestExceptionHandlerWrapper extends RestExceptionHandler {
  42         @Override
  43         public  ResponseEntity<Object> handleHttpRequestMethodNotSupported(HttpRequestMethodNotSupportedException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) {
  44             return super.handleHttpRequestMethodNotSupported(ex, headers, status, request);
  45         }
  46
  47         @Override
  48         public ResponseEntity<Object> handleHttpMediaTypeNotSupported(HttpMediaTypeNotSupportedException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) {
  49             return super.handleHttpMediaTypeNotSupported(ex, headers, status, request);
  50         }
  51
  52         @Override
  53         public ResponseEntity<Object> handleHttpMediaTypeNotAcceptable(HttpMediaTypeNotAcceptableException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) {
  54             return super.handleHttpMediaTypeNotAcceptable(ex, headers, status, request);
  55         }
  56
  57         @Override
  58         protected ResponseEntity<Object> handleMissingPathVariable(MissingPathVariableException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) {
  59             return super.handleMissingPathVariable(ex, headers, status, request);
  60         }
  61
  62         @Override
  63         public ResponseEntity<Object> handleMissingServletRequestParameter(MissingServletRequestParameterException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) {
  64             return super.handleMissingServletRequestParameter(ex, headers, status, request);
  65         }
  66
  67         @Override
  68         public ResponseEntity<Object> handleServletRequestBindingException(ServletRequestBindingException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) {
  69             return super.handleServletRequestBindingException(ex, headers, status, request);
  70         }
  71
  72         @Override
  73         public ResponseEntity<Object> handleConversionNotSupported(ConversionNotSupportedException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) {
  74             return super.handleConversionNotSupported(ex, headers, status, request);
  75         }
  76
  77         @Override
  78         public ResponseEntity<Object> handleTypeMismatch(TypeMismatchException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) {
  79             return super.handleTypeMismatch(ex, headers, status, request);
  80         }
  81
  82         @Override
  83         public ResponseEntity<Object> handleHttpMessageNotReadable(HttpMessageNotReadableException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) {
  84             return super.handleHttpMessageNotReadable(ex, headers, status, request);
  85         }
  86
  87         @Override
  88         public ResponseEntity<Object> handleHttpMessageNotWritable(HttpMessageNotWritableException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) {
  89             return super.handleHttpMessageNotWritable(ex, headers, status, request);
  90         }
  91
  92         @Override
  93         public ResponseEntity<Object> handleMethodArgumentNotValid(MethodArgumentNotValidException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) {
  94             return super.handleMethodArgumentNotValid(ex, headers, status, request);
  95         }
  96
  97         @Override
  98         public ResponseEntity<Object> handleMissingServletRequestPart(MissingServletRequestPartException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) {
  99             return super.handleMissingServletRequestPart(ex, headers, status, request);
 100         }
 101
 102         @Override
 103         public ResponseEntity<Object> handleBindException(BindException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) {
 104             return super.handleBindException(ex, headers, status, request);
 105         }
 106
 107         @Override
 108         public ResponseEntity<Object> handleNoHandlerFoundException(NoHandlerFoundException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) {
 109             return super.handleNoHandlerFoundException(ex, headers, status, request);
 110         }
 111
 112         @Override
 113         public ResponseEntity<Object> handleAsyncRequestTimeoutException(AsyncRequestTimeoutException ex, HttpHeaders headers, HttpStatusCode status, WebRequest webRequest) {
 114             return super.handleAsyncRequestTimeoutException(ex, headers, status, webRequest);
 115         }
 116
 117         @Override
 118         public ResponseEntity<Object> handleExceptionInternal(Exception ex, Object body, HttpHeaders headers, HttpStatusCode status, WebRequest request) {
 119             return super.handleExceptionInternal(ex, body, headers, status, request);
 120         }
 121     }
 122
 123     RestExceptionHandler handler;
 124
 125     @Before
 126     public void setUp() {
 127         handler = new RestExceptionHandlerWrapper();
 128     }
 129
 130     @Test
 131     public void handleHttpRequestMethodNotSupported() throws JsonProcessingException {
 132         String[] supportedMethods = {"GET", "POST", "PUT", "DELETE"};
 133
 134
 135         ResponseEntity<Object> respEntity = handler.handleHttpRequestMethodNotSupported(new HttpRequestMethodNotSupportedException("PATCH", supportedMethods),
 136                 null, HttpStatus.METHOD_NOT_ALLOWED, null);
 137
 138         assertTrue(respEntity.hasBody());
 139         assertTrue(respEntity.getBody() instanceof RestErrors);
 140
 141         RestErrors restErrors = (RestErrors) respEntity.getBody();
 142
 143         ObjectMapper objectMapper = new ObjectMapper();
 144         log.info("response : {}", objectMapper.writeValueAsString(restErrors));
 145
 146
 147     }
 148
 149     @Test
 150     public void handleHttpMediaTypeNotSupported() throws JsonProcessingException {
 151         MediaType[] supportedMediaTypeArray = { MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML};
 152
 153         ResponseEntity<Object> respEntity = handler.handleHttpMediaTypeNotSupported(new HttpMediaTypeNotSupportedException(MediaType.MULTIPART_MIXED, Arrays.asList(supportedMediaTypeArray)),
 154                 null, HttpStatus.UNSUPPORTED_MEDIA_TYPE, null);
 155
 156         assertTrue(respEntity.hasBody());
 157         assertTrue(respEntity.getBody() instanceof RestErrors);
 158
 159         RestErrors restErrors = (RestErrors) respEntity.getBody();
 160         ObjectMapper objectMapper = new ObjectMapper();
 161         log.info("response : {}", objectMapper.writeValueAsString(restErrors));
 162     }
 163
 164     @Test
 165     public void handleHttpMediaTypeNotAcceptable() throws JsonProcessingException {
 166         MediaType[] supportedMediaTypeArray = { MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML};
 167
 168         ResponseEntity<Object> respEntity = handler.handleHttpMediaTypeNotAcceptable(new HttpMediaTypeNotAcceptableException(Arrays.asList(supportedMediaTypeArray)),
 169                 null, HttpStatus.UNSUPPORTED_MEDIA_TYPE, null);
 170
 171         assertTrue(respEntity.hasBody());
 172         assertTrue(respEntity.getBody() instanceof RestErrors);
 173
 174         RestErrors restErrors = (RestErrors) respEntity.getBody();
 175
 176         ObjectMapper objectMapper = new ObjectMapper();
 177         log.info("response : {}", objectMapper.writeValueAsString(restErrors));
 178
 179     }
 180
 181     @Test
 182     public void handleMissingPathVariable() throws JsonProcessingException {
 183         ResponseEntity<Object> respEntity = handler.handleMissingPathVariable(new MissingPathVariableException("test", new MethodParameter(RestApplicationError.class.getDeclaredConstructors()[0],-1)),
 184                 null, HttpStatus.INTERNAL_SERVER_ERROR, null);
 185
 186         assertTrue(respEntity.hasBody());
 187         assertTrue(respEntity.getBody() instanceof RestErrors);
 188
 189         RestErrors restErrors = (RestErrors) respEntity.getBody();
 190         ObjectMapper objectMapper = new ObjectMapper();
 191         log.info("response : {}", objectMapper.writeValueAsString(restErrors));
 192     }
 193
 194     @Test
 195     public void handleMissingServletRequestParameter() throws JsonProcessingException {
 196         ResponseEntity<Object> respEntity = handler.handleMissingServletRequestParameter(new MissingServletRequestParameterException("test", "string"),
 197                 null, HttpStatus.INTERNAL_SERVER_ERROR, null);
 198
 199         assertTrue(respEntity.hasBody());
 200         assertTrue(respEntity.getBody() instanceof RestErrors);
 201
 202         RestErrors restErrors = (RestErrors) respEntity.getBody();
 203         ObjectMapper objectMapper = new ObjectMapper();
 204         log.info("response : {}", objectMapper.writeValueAsString(restErrors));
 205     }
 206
 207     @Test
 208     public void handleServletRequestBindingException() throws JsonProcessingException {
 209         ResponseEntity<Object> respEntity = handler.handleServletRequestBindingException(new ServletRequestBindingException("servlet request binding error"),
 210                 null, HttpStatus.INTERNAL_SERVER_ERROR, null);
 211
 212         assertTrue(respEntity.hasBody());
 213         assertTrue(respEntity.getBody() instanceof RestErrors);
 214
 215         RestErrors restErrors = (RestErrors) respEntity.getBody();
 216         ObjectMapper objectMapper = new ObjectMapper();
 217         log.info("response : {}", objectMapper.writeValueAsString(restErrors));
 218     }
 219
 220     @Test
 221     public void handleConversionNotSupported() throws JsonProcessingException {
 222         ResponseEntity<Object> respEntity = handler.handleConversionNotSupported(new ConversionNotSupportedException("hello", Integer.class, new NumberFormatException()),
 223                 null, HttpStatus.INTERNAL_SERVER_ERROR, null);
 224
 225         assertTrue(respEntity.hasBody());
 226         assertTrue(respEntity.getBody() instanceof RestErrors);
 227
 228         RestErrors restErrors = (RestErrors) respEntity.getBody();
 229         ObjectMapper objectMapper = new ObjectMapper();
 230         log.info("response : {}", objectMapper.writeValueAsString(restErrors));
 231     }
 232
 233     @Test
 234     public void handleTypeMismatch() throws JsonProcessingException {
 235         ResponseEntity<Object> respEntity = handler.handleTypeMismatch(new TypeMismatchException("hello", Integer.class, new NumberFormatException()),
 236                 null, HttpStatus.INTERNAL_SERVER_ERROR, null);
 237
 238         assertTrue(respEntity.hasBody());
 239         assertTrue(respEntity.getBody() instanceof RestErrors);
 240
 241         RestErrors restErrors = (RestErrors) respEntity.getBody();
 242         ObjectMapper objectMapper = new ObjectMapper();
 243         log.info("response : {}", objectMapper.writeValueAsString(restErrors));
 244     }
 245
 246     @Test
 247     public void handleHttpMessageNotReadable() throws JsonProcessingException {
 248         ResponseEntity<Object> respEntity = handler.handleHttpMessageNotReadable(new HttpMessageNotReadableException("Message not readable"),
 249                 null, HttpStatus.INTERNAL_SERVER_ERROR, null);
 250
 251         assertTrue(respEntity.hasBody());
 252         assertTrue(respEntity.getBody() instanceof RestErrors);
 253
 254         RestErrors restErrors = (RestErrors) respEntity.getBody();
 255         ObjectMapper objectMapper = new ObjectMapper();
 256         log.info("response : {}", objectMapper.writeValueAsString(restErrors));
 257     }
 258
 259     @Test
 260     public void handleHttpMessageNotWritable() throws JsonProcessingException {
 261         ResponseEntity<Object> respEntity = handler.handleHttpMessageNotWritable(new HttpMessageNotWritableException("Message not writable"),
 262                 null, HttpStatus.INTERNAL_SERVER_ERROR, null);
 263
 264         assertTrue(respEntity.hasBody());
 265         assertTrue(respEntity.getBody() instanceof RestErrors);
 266
 267         RestErrors restErrors = (RestErrors) respEntity.getBody();
 268         ObjectMapper objectMapper = new ObjectMapper();
 269         log.info("response : {}", objectMapper.writeValueAsString(restErrors));
 270     }
 271
 272     @Test
 273     public void handleMethodArgumentNotValid() throws JsonProcessingException {
 274         ResponseEntity<Object> respEntity = handler.handleMethodArgumentNotValid(new MethodArgumentNotValidException(new MethodParameter(RestApplicationError.class.getDeclaredConstructors()[0],-1),
 275                         new BindException("target", "objectName")),
 276                 null, HttpStatus.INTERNAL_SERVER_ERROR, null);
 277
 278         assertTrue(respEntity.hasBody());
 279         assertTrue(respEntity.getBody() instanceof RestErrors);
 280
 281         RestErrors restErrors = (RestErrors) respEntity.getBody();
 282         ObjectMapper objectMapper = new ObjectMapper();
 283         log.info("response : {}", objectMapper.writeValueAsString(restErrors));
 284     }
 285
 286     @Test
 287     public void handleMissingServletRequestPart() throws JsonProcessingException {
 288         ResponseEntity<Object> respEntity = handler.handleMissingServletRequestPart(new MissingServletRequestPartException("test"),
 289                 null, HttpStatus.INTERNAL_SERVER_ERROR, null);
 290
 291         assertTrue(respEntity.hasBody());
 292         assertTrue(respEntity.getBody() instanceof RestErrors);
 293
 294         RestErrors restErrors = (RestErrors) respEntity.getBody();
 295         ObjectMapper objectMapper = new ObjectMapper();
 296         log.info("response : {}", objectMapper.writeValueAsString(restErrors));
 297     }
 298
 299     @Test
 300     public void handleBindException() throws JsonProcessingException {
 301         ResponseEntity<Object> respEntity = handler.handleBindException(new BindException("target", "objectName"),
 302                 null, HttpStatus.INTERNAL_SERVER_ERROR, null);
 303
 304         assertTrue(respEntity.hasBody());
 305         assertTrue(respEntity.getBody() instanceof RestErrors);
 306
 307         RestErrors restErrors = (RestErrors) respEntity.getBody();
 308         ObjectMapper objectMapper = new ObjectMapper();
 309         log.info("response : {}", objectMapper.writeValueAsString(restErrors));
 310     }
 311
 312     @Test
 313     public void handleNoHandlerFoundException() throws JsonProcessingException {
 314         ResponseEntity<Object> respEntity = handler.handleNoHandlerFoundException(new NoHandlerFoundException("GET", "restconf/bogus", null),
 315                 null, HttpStatus.INTERNAL_SERVER_ERROR, null);
 316
 317         assertTrue(respEntity.hasBody());
 318         assertTrue(respEntity.getBody() instanceof RestErrors);
 319
 320         RestErrors restErrors = (RestErrors) respEntity.getBody();
 321         ObjectMapper objectMapper = new ObjectMapper();
 322         log.info("response : {}", objectMapper.writeValueAsString(restErrors));
 323     }
 324
 325     @Test
 326     public void handleAsyncRequestTimeoutException() throws JsonProcessingException {
 327         ResponseEntity<Object> respEntity = handler.handleAsyncRequestTimeoutException(new AsyncRequestTimeoutException(),
 328                 null, HttpStatus.INTERNAL_SERVER_ERROR, null);
 329
 330         assertTrue(respEntity.hasBody());
 331         assertTrue(respEntity.getBody() instanceof RestErrors);
 332
 333         RestErrors restErrors = (RestErrors) respEntity.getBody();
 334         ObjectMapper objectMapper = new ObjectMapper();
 335         log.info("response : {}", objectMapper.writeValueAsString(restErrors));
 336     }
 337
 338     @Test
 339     public void handleExceptionInternal() throws JsonProcessingException {
 340         ResponseEntity<Object> respEntity = handler.handleExceptionInternal(new NullPointerException(), null,
 341                 null, HttpStatus.INTERNAL_SERVER_ERROR, null);
 342
 343         assertTrue(respEntity.hasBody());
 344         assertTrue(respEntity.getBody() instanceof RestErrors);
 345
 346         RestErrors restErrors = (RestErrors) respEntity.getBody();
 347         ObjectMapper objectMapper = new ObjectMapper();
 348         log.info("response : {}", objectMapper.writeValueAsString(restErrors));
 349     }
 350
 351     @Test
 352     public void handleRestException() throws JsonProcessingException {
 353
 354         ResponseEntity<Object> respEntity = handler.handleRestException(new RestApplicationException("no-data-found", "No data found", HttpStatus.NOT_FOUND.value()), null);
 355         assertTrue(respEntity.hasBody());
 356         assertTrue(respEntity.getBody() instanceof RestErrors);
 357
 358         RestErrors restErrors = (RestErrors) respEntity.getBody();
 359         ObjectMapper objectMapper = new ObjectMapper();
 360         log.info("response : {}", objectMapper.writeValueAsString(restErrors));
 361     }
 362
 363 }