private HandlerResponse<T> createErrorResponse(Exception e, int statusCode) { ErrorResponse errorResp = unwrapException(e); try { return new HandlerResponse<>(encode(errorResp), statusCode); } catch (IOException e1) { // TODO provide a canned ErrorResponse // If we can't serialize the error message, we can't give a meaningful error to caller. // Just try to not unnecessarily create more exceptions. if (e instanceof RuntimeException) { throw (RuntimeException) e; } throw new RuntimeException(e); } }
private HandlerResponse<T> createErrorResponse(Exception e, int statusCode) { ErrorResponse errorResp = unwrapException(e); try { return new HandlerResponse<>(encode(errorResp), statusCode); } catch (IOException e1) { // TODO provide a canned ErrorResponse // If we can't serialize the error message, we can't give a meaningful error to caller. // Just try to not unnecessarily create more exceptions. if (e instanceof RuntimeException) { throw (RuntimeException) e; } throw new RuntimeException(e); } }
return new HandlerResponse<>(encode(response), HTTP_OK); } catch (Exception e) { ErrorResponse errorResp = unwrapException(e);
@Test public void testFailedErrorResponseSerialization() throws IOException { @SuppressWarnings("unchecked") final AbstractHandler<String> handler = Mockito.mock(AbstractHandler.class); final Request request = Mockito.mock(Request.class); final Response response = Mockito.mock(Response.class); final IOException exception = new IOException(); final ErrorResponse errorResponse = Mockito.mock(ErrorResponse.class); // Accept a serialized request Mockito.when(handler.apply(Mockito.anyString())).thenCallRealMethod(); // Deserialize it back into a POJO Mockito.when(handler.decode(Mockito.anyString())).thenReturn(request); // Construct the Response for that Request Mockito.when(request.accept(Mockito.any(Service.class))).thenReturn(response); // Throw an IOException when serializing the Response. Mockito.when(handler.encode(response)).thenThrow(exception); // Convert the IOException into an ErrorResponse Mockito.when(handler.unwrapException(exception)).thenReturn(errorResponse); // Fail to serialize the ErrorResponse Mockito.when(handler.encode(errorResponse)).thenThrow(exception); try { handler.apply("this is mocked out"); } catch (RuntimeException e) { assertEquals(exception, e.getCause()); } }
@Test public void testFailedErrorResponseSerialization() throws IOException { @SuppressWarnings("unchecked") final AbstractHandler<String> handler = Mockito.mock(AbstractHandler.class); final Request request = Mockito.mock(Request.class); final Response response = Mockito.mock(Response.class); final IOException exception = new IOException(); final ErrorResponse errorResponse = Mockito.mock(ErrorResponse.class); // Accept a serialized request Mockito.when(handler.apply(Mockito.anyString())).thenCallRealMethod(); // Deserialize it back into a POJO Mockito.when(handler.decode(Mockito.anyString())).thenReturn(request); // Construct the Response for that Request Mockito.when(request.accept(Mockito.any(Service.class))).thenReturn(response); // Throw an IOException when serializing the Response. Mockito.when(handler.encode(response)).thenThrow(exception); // Convert the IOException into an ErrorResponse Mockito.when(handler.unwrapException(exception)).thenReturn(errorResponse); // Fail to serialize the ErrorResponse Mockito.when(handler.encode(errorResponse)).thenThrow(exception); try { handler.apply("this is mocked out"); } catch (RuntimeException e) { assertEquals(exception, e.getCause()); } }
@Test public void testFailedErrorResponseSerialization() throws IOException { @SuppressWarnings("unchecked") final AbstractHandler<String> handler = Mockito.mock(AbstractHandler.class); final Request request = Mockito.mock(Request.class); final Response response = Mockito.mock(Response.class); final IOException exception = new IOException(); final ErrorResponse errorResponse = Mockito.mock(ErrorResponse.class); // Accept a serialized request Mockito.when(handler.apply(Mockito.anyString())).thenCallRealMethod(); // Deserialize it back into a POJO Mockito.when(handler.decode(Mockito.anyString())).thenReturn(request); // Construct the Response for that Request Mockito.when(request.accept(Mockito.any(Service.class))).thenReturn(response); // Throw an IOException when serializing the Response. Mockito.when(handler.encode(response)).thenThrow(exception); // Convert the IOException into an ErrorResponse Mockito.when(handler.unwrapException(exception)).thenReturn(errorResponse); // Fail to serialize the ErrorResponse Mockito.when(handler.encode(errorResponse)).thenThrow(exception); try { handler.apply("this is mocked out"); } catch (RuntimeException e) { assertEquals(exception, e.getCause()); } }
@Test public void testFailedResponseSerialization() throws IOException { @SuppressWarnings("unchecked") final AbstractHandler<String> handler = Mockito.mock(AbstractHandler.class); final Request request = Mockito.mock(Request.class); final Response response = Mockito.mock(Response.class); final IOException exception = new IOException(); final ErrorResponse errorResponse = Mockito.mock(ErrorResponse.class); final String serializedErrorResponse = "An ErrorResponse"; // Accept a serialized request Mockito.when(handler.apply(Mockito.anyString())).thenCallRealMethod(); // Deserialize it back into a POJO Mockito.when(handler.decode(Mockito.anyString())).thenReturn(request); // Construct the Response for that Request Mockito.when(request.accept(Mockito.any(Service.class))).thenReturn(response); // Throw an IOException when serializing the Response. Mockito.when(handler.encode(response)).thenThrow(exception); // Convert the IOException into an ErrorResponse Mockito.when(handler.unwrapException(exception)).thenReturn(errorResponse); Mockito.when(handler.encode(errorResponse)).thenReturn(serializedErrorResponse); HandlerResponse<String> handlerResp = handler.apply("this is mocked out"); assertEquals(500, handlerResp.getStatusCode()); assertEquals(serializedErrorResponse, handlerResp.getResponse()); }
@Test public void testExceptionUnwrappingWithContext() { @SuppressWarnings("unchecked") AbstractHandler<String> handler = Mockito.mock(AbstractHandler.class); Mockito.when(handler.unwrapException(Mockito.any(Exception.class))).thenCallRealMethod(); final String msg = "Something failed!"; AvaticaRuntimeException e = new AvaticaRuntimeException(msg, ErrorResponse.UNKNOWN_ERROR_CODE, ErrorResponse.UNKNOWN_SQL_STATE, AvaticaSeverity.FATAL); Response resp = handler.unwrapException(e); assertTrue("Response should be ErrorResponse, but was " + resp.getClass(), resp instanceof ErrorResponse); ErrorResponse errorResp = (ErrorResponse) resp; assertEquals(ErrorResponse.UNKNOWN_ERROR_CODE, errorResp.errorCode); assertEquals(AvaticaSeverity.FATAL, errorResp.severity); assertEquals(Arrays.asList(exceptionToString(e)), errorResp.exceptions); assertEquals(msg, errorResp.errorMessage); }
@Test public void testExceptionUnwrappingWithContext() { @SuppressWarnings("unchecked") AbstractHandler<String> handler = Mockito.mock(AbstractHandler.class); Mockito.when(handler.unwrapException(Mockito.any(Exception.class))).thenCallRealMethod(); final String msg = "Something failed!"; AvaticaRuntimeException e = new AvaticaRuntimeException(msg, ErrorResponse.UNKNOWN_ERROR_CODE, ErrorResponse.UNKNOWN_SQL_STATE, AvaticaSeverity.FATAL); Response resp = handler.unwrapException(e); assertTrue("Response should be ErrorResponse, but was " + resp.getClass(), resp instanceof ErrorResponse); ErrorResponse errorResp = (ErrorResponse) resp; assertEquals(ErrorResponse.UNKNOWN_ERROR_CODE, errorResp.errorCode); assertEquals(AvaticaSeverity.FATAL, errorResp.severity); assertEquals(Arrays.asList(exceptionToString(e)), errorResp.exceptions); assertEquals(msg, errorResp.errorMessage); }
@Test public void testExceptionUnwrappingWithContext() { @SuppressWarnings("unchecked") AbstractHandler<String> handler = Mockito.mock(AbstractHandler.class); Mockito.when(handler.unwrapException(Mockito.any(Exception.class))).thenCallRealMethod(); final String msg = "Something failed!"; AvaticaRuntimeException e = new AvaticaRuntimeException(msg, ErrorResponse.UNKNOWN_ERROR_CODE, ErrorResponse.UNKNOWN_SQL_STATE, AvaticaSeverity.FATAL); Response resp = handler.unwrapException(e); assertTrue("Response should be ErrorResponse, but was " + resp.getClass(), resp instanceof ErrorResponse); ErrorResponse errorResp = (ErrorResponse) resp; assertEquals(ErrorResponse.UNKNOWN_ERROR_CODE, errorResp.errorCode); assertEquals(AvaticaSeverity.FATAL, errorResp.severity); assertEquals(Arrays.asList(exceptionToString(e)), errorResp.exceptions); assertEquals(msg, errorResp.errorMessage); }
@Test public void testFailedResponseSerialization() throws IOException { @SuppressWarnings("unchecked") final AbstractHandler<String> handler = Mockito.mock(AbstractHandler.class); final Request request = Mockito.mock(Request.class); final Response response = Mockito.mock(Response.class); final IOException exception = new IOException(); final ErrorResponse errorResponse = Mockito.mock(ErrorResponse.class); final String serializedErrorResponse = "An ErrorResponse"; // Accept a serialized request Mockito.when(handler.apply(Mockito.anyString())).thenCallRealMethod(); // Deserialize it back into a POJO Mockito.when(handler.decode(Mockito.anyString())).thenReturn(request); // Construct the Response for that Request Mockito.when(request.accept(Mockito.nullable(Service.class))).thenReturn(response); // Throw an IOException when serializing the Response. Mockito.when(handler.encode(response)).thenThrow(exception); Mockito.when(handler.convertToErrorResponse(exception)).thenCallRealMethod(); // Convert the IOException into an ErrorResponse Mockito.when(handler.unwrapException(exception)).thenReturn(errorResponse); Mockito.when(handler.encode(errorResponse)).thenReturn(serializedErrorResponse); HandlerResponse<String> handlerResp = handler.apply("this is mocked out"); assertEquals(500, handlerResp.getStatusCode()); assertEquals(serializedErrorResponse, handlerResp.getResponse()); }
@Test public void testFailedRequestDeserialization() throws IOException { @SuppressWarnings("unchecked") final AbstractHandler<String> handler = Mockito.mock(AbstractHandler.class); final IOException exception = new IOException(); final ErrorResponse errorResponse = new ErrorResponse(); final String serializedErrorResponse = "Serialized ErrorResponse"; // Faked out // Accept a serialized request Mockito.when(handler.apply(Mockito.anyString())).thenCallRealMethod(); // Throw an Exception trying to convert it back into a POJO Mockito.when(handler.decode(Mockito.anyString())).thenThrow(exception); Mockito.when(handler.convertToErrorResponse(exception)).thenCallRealMethod(); Mockito.when(handler.unwrapException(exception)).thenReturn(errorResponse); Mockito.when(handler.encode(errorResponse)).thenReturn(serializedErrorResponse); HandlerResponse<String> response = handler.apply("this is mocked out"); assertEquals(serializedErrorResponse, response.getResponse()); assertEquals(500, response.getStatusCode()); } }
@Test public void testExceptionUnwrappingWithoutContext() { @SuppressWarnings("unchecked") AbstractHandler<String> handler = Mockito.mock(AbstractHandler.class); Mockito.when(handler.unwrapException(Mockito.any(Exception.class))).thenCallRealMethod(); Exception e = new RuntimeException(); Response resp = handler.unwrapException(e); assertTrue("Response should be ErrorResponse, but was " + resp.getClass(), resp instanceof ErrorResponse); ErrorResponse errorResp = (ErrorResponse) resp; assertEquals(ErrorResponse.UNKNOWN_ERROR_CODE, errorResp.errorCode); assertEquals(AvaticaSeverity.UNKNOWN, errorResp.severity); assertEquals(Arrays.asList(exceptionToString(e)), errorResp.exceptions); e = new AvaticaRuntimeException(); resp = handler.unwrapException(e); assertTrue("Response should be ErrorResponse, but was " + resp.getClass(), resp instanceof ErrorResponse); errorResp = (ErrorResponse) resp; assertEquals(ErrorResponse.UNKNOWN_ERROR_CODE, errorResp.errorCode); assertEquals(AvaticaSeverity.UNKNOWN, errorResp.severity); assertEquals(Arrays.asList(exceptionToString(e)), errorResp.exceptions); }
@Test public void testExceptionUnwrappingWithoutContext() { @SuppressWarnings("unchecked") AbstractHandler<String> handler = Mockito.mock(AbstractHandler.class); Mockito.when(handler.unwrapException(Mockito.any(Exception.class))).thenCallRealMethod(); Exception e = new RuntimeException(); Response resp = handler.unwrapException(e); assertTrue("Response should be ErrorResponse, but was " + resp.getClass(), resp instanceof ErrorResponse); ErrorResponse errorResp = (ErrorResponse) resp; assertEquals(ErrorResponse.UNKNOWN_ERROR_CODE, errorResp.errorCode); assertEquals(AvaticaSeverity.UNKNOWN, errorResp.severity); assertEquals(Arrays.asList(exceptionToString(e)), errorResp.exceptions); e = new AvaticaRuntimeException(); resp = handler.unwrapException(e); assertTrue("Response should be ErrorResponse, but was " + resp.getClass(), resp instanceof ErrorResponse); errorResp = (ErrorResponse) resp; assertEquals(ErrorResponse.UNKNOWN_ERROR_CODE, errorResp.errorCode); assertEquals(AvaticaSeverity.UNKNOWN, errorResp.severity); assertEquals(Arrays.asList(exceptionToString(e)), errorResp.exceptions); }
@Test public void testExceptionUnwrappingWithoutContext() { @SuppressWarnings("unchecked") AbstractHandler<String> handler = Mockito.mock(AbstractHandler.class); Mockito.when(handler.unwrapException(Mockito.any(Exception.class))).thenCallRealMethod(); Exception e = new RuntimeException(); Response resp = handler.unwrapException(e); assertTrue("Response should be ErrorResponse, but was " + resp.getClass(), resp instanceof ErrorResponse); ErrorResponse errorResp = (ErrorResponse) resp; assertEquals(ErrorResponse.UNKNOWN_ERROR_CODE, errorResp.errorCode); assertEquals(AvaticaSeverity.UNKNOWN, errorResp.severity); assertEquals(Arrays.asList(exceptionToString(e)), errorResp.exceptions); e = new AvaticaRuntimeException(); resp = handler.unwrapException(e); assertTrue("Response should be ErrorResponse, but was " + resp.getClass(), resp instanceof ErrorResponse); errorResp = (ErrorResponse) resp; assertEquals(ErrorResponse.UNKNOWN_ERROR_CODE, errorResp.errorCode); assertEquals(AvaticaSeverity.UNKNOWN, errorResp.severity); assertEquals(Arrays.asList(exceptionToString(e)), errorResp.exceptions); }
@Test public void testFailedRequestDeserialization() throws IOException { @SuppressWarnings("unchecked") final AbstractHandler<String> handler = Mockito.mock(AbstractHandler.class); final IOException exception = new IOException(); final ErrorResponse errorResponse = new ErrorResponse(); final String serializedErrorResponse = "Serialized ErrorResponse"; // Faked out // Accept a serialized request Mockito.when(handler.apply(Mockito.anyString())).thenCallRealMethod(); // Throw an Exception trying to convert it back into a POJO Mockito.when(handler.decode(Mockito.anyString())).thenThrow(exception); Mockito.when(handler.convertToErrorResponse(exception)).thenCallRealMethod(); Mockito.when(handler.unwrapException(exception)).thenReturn(errorResponse); Mockito.when(handler.encode(errorResponse)).thenReturn(serializedErrorResponse); HandlerResponse<String> response = handler.apply("this is mocked out"); assertEquals(serializedErrorResponse, response.getResponse()); assertEquals(500, response.getStatusCode()); } }
@Test public void testFailedResponseSerialization() throws IOException { @SuppressWarnings("unchecked") final AbstractHandler<String> handler = Mockito.mock(AbstractHandler.class); final Request request = Mockito.mock(Request.class); final Response response = Mockito.mock(Response.class); final IOException exception = new IOException(); final ErrorResponse errorResponse = Mockito.mock(ErrorResponse.class); final String serializedErrorResponse = "An ErrorResponse"; // Accept a serialized request Mockito.when(handler.apply(Mockito.anyString())).thenCallRealMethod(); // Deserialize it back into a POJO Mockito.when(handler.decode(Mockito.anyString())).thenReturn(request); // Construct the Response for that Request Mockito.when(request.accept(Mockito.nullable(Service.class))).thenReturn(response); // Throw an IOException when serializing the Response. Mockito.when(handler.encode(response)).thenThrow(exception); Mockito.when(handler.convertToErrorResponse(exception)).thenCallRealMethod(); // Convert the IOException into an ErrorResponse Mockito.when(handler.unwrapException(exception)).thenReturn(errorResponse); Mockito.when(handler.encode(errorResponse)).thenReturn(serializedErrorResponse); HandlerResponse<String> handlerResp = handler.apply("this is mocked out"); assertEquals(500, handlerResp.getStatusCode()); assertEquals(serializedErrorResponse, handlerResp.getResponse()); }