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