target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test public void shouldSendErrorWithMessage() throws Exception { httpResult.sendError(SC_INTERNAL_SERVER_ERROR, "A simple message"); verify(response).sendError(SC_INTERNAL_SERVER_ERROR, "A simple message"); } | @Override public void sendError(int statusCode) { try { response.sendError(statusCode); } catch (IOException e) { throw new ResultException("Error while setting status code", e); } } | DefaultHttpResult implements HttpResult { @Override public void sendError(int statusCode) { try { response.sendError(statusCode); } catch (IOException e) { throw new ResultException("Error while setting status code", e); } } } | DefaultHttpResult implements HttpResult { @Override public void sendError(int statusCode) { try { response.sendError(statusCode); } catch (IOException e) { throw new ResultException("Error while setting status code", e); } } protected DefaultHttpResult(); @Inject DefaultHttpResult(HttpServletResponse response, Status status); } | DefaultHttpResult implements HttpResult { @Override public void sendError(int statusCode) { try { response.sendError(statusCode); } catch (IOException e) { throw new ResultException("Error while setting status code", e); } } protected DefaultHttpResult(); @Inject DefaultHttpResult(HttpServletResponse response, Status status); @Override HttpResult addDateHeader(String name, long date); @Override HttpResult addHeader(String name, String value); @Override HttpResult addIntHeader(String name, int value); @Override void sendError(int statusCode); @Override void sendError(int statusCode, String message); @Override void setStatusCode(int statusCode); void movedPermanentlyTo(String uri); T movedPermanentlyTo(final Class<T> controller); @Override HttpResult body(String body); @Override HttpResult body(InputStream body); @Override HttpResult body(Reader body); } | DefaultHttpResult implements HttpResult { @Override public void sendError(int statusCode) { try { response.sendError(statusCode); } catch (IOException e) { throw new ResultException("Error while setting status code", e); } } protected DefaultHttpResult(); @Inject DefaultHttpResult(HttpServletResponse response, Status status); @Override HttpResult addDateHeader(String name, long date); @Override HttpResult addHeader(String name, String value); @Override HttpResult addIntHeader(String name, int value); @Override void sendError(int statusCode); @Override void sendError(int statusCode, String message); @Override void setStatusCode(int statusCode); void movedPermanentlyTo(String uri); T movedPermanentlyTo(final Class<T> controller); @Override HttpResult body(String body); @Override HttpResult body(InputStream body); @Override HttpResult body(Reader body); } |
@Test public void shouldThrowResultExceptionIfAnIOExceptionWhenSendErrorWithMessage() throws Exception { doThrow(new IOException()).when(response).sendError(anyInt(), anyString()); try { httpResult.sendError(SC_INTERNAL_SERVER_ERROR, "A simple message"); fail("should throw ResultException"); } catch (ResultException e) { verify(response, only()).sendError(anyInt(), anyString()); } } | @Override public void sendError(int statusCode) { try { response.sendError(statusCode); } catch (IOException e) { throw new ResultException("Error while setting status code", e); } } | DefaultHttpResult implements HttpResult { @Override public void sendError(int statusCode) { try { response.sendError(statusCode); } catch (IOException e) { throw new ResultException("Error while setting status code", e); } } } | DefaultHttpResult implements HttpResult { @Override public void sendError(int statusCode) { try { response.sendError(statusCode); } catch (IOException e) { throw new ResultException("Error while setting status code", e); } } protected DefaultHttpResult(); @Inject DefaultHttpResult(HttpServletResponse response, Status status); } | DefaultHttpResult implements HttpResult { @Override public void sendError(int statusCode) { try { response.sendError(statusCode); } catch (IOException e) { throw new ResultException("Error while setting status code", e); } } protected DefaultHttpResult(); @Inject DefaultHttpResult(HttpServletResponse response, Status status); @Override HttpResult addDateHeader(String name, long date); @Override HttpResult addHeader(String name, String value); @Override HttpResult addIntHeader(String name, int value); @Override void sendError(int statusCode); @Override void sendError(int statusCode, String message); @Override void setStatusCode(int statusCode); void movedPermanentlyTo(String uri); T movedPermanentlyTo(final Class<T> controller); @Override HttpResult body(String body); @Override HttpResult body(InputStream body); @Override HttpResult body(Reader body); } | DefaultHttpResult implements HttpResult { @Override public void sendError(int statusCode) { try { response.sendError(statusCode); } catch (IOException e) { throw new ResultException("Error while setting status code", e); } } protected DefaultHttpResult(); @Inject DefaultHttpResult(HttpServletResponse response, Status status); @Override HttpResult addDateHeader(String name, long date); @Override HttpResult addHeader(String name, String value); @Override HttpResult addIntHeader(String name, int value); @Override void sendError(int statusCode); @Override void sendError(int statusCode, String message); @Override void setStatusCode(int statusCode); void movedPermanentlyTo(String uri); T movedPermanentlyTo(final Class<T> controller); @Override HttpResult body(String body); @Override HttpResult body(InputStream body); @Override HttpResult body(Reader body); } |
@Test public void addsAPrefixToMethodsWhenTheControllerIsAnnotatedWithPath() throws Exception { List<Route> routes = parser.rulesFor(new DefaultBeanClass(PathAnnotatedController.class)); Route route = getRouteMatching(routes, "/prefix/withoutPath"); assertThat(route, canHandle(PathAnnotatedController.class, "withoutPath")); } | @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); } |
@Test public void shouldSetStatusCode() throws Exception { httpResult.setStatusCode(SC_INTERNAL_SERVER_ERROR); verify(response).setStatus(SC_INTERNAL_SERVER_ERROR); } | @Override public void setStatusCode(int statusCode) { response.setStatus(statusCode); } | DefaultHttpResult implements HttpResult { @Override public void setStatusCode(int statusCode) { response.setStatus(statusCode); } } | DefaultHttpResult implements HttpResult { @Override public void setStatusCode(int statusCode) { response.setStatus(statusCode); } protected DefaultHttpResult(); @Inject DefaultHttpResult(HttpServletResponse response, Status status); } | DefaultHttpResult implements HttpResult { @Override public void setStatusCode(int statusCode) { response.setStatus(statusCode); } protected DefaultHttpResult(); @Inject DefaultHttpResult(HttpServletResponse response, Status status); @Override HttpResult addDateHeader(String name, long date); @Override HttpResult addHeader(String name, String value); @Override HttpResult addIntHeader(String name, int value); @Override void sendError(int statusCode); @Override void sendError(int statusCode, String message); @Override void setStatusCode(int statusCode); void movedPermanentlyTo(String uri); T movedPermanentlyTo(final Class<T> controller); @Override HttpResult body(String body); @Override HttpResult body(InputStream body); @Override HttpResult body(Reader body); } | DefaultHttpResult implements HttpResult { @Override public void setStatusCode(int statusCode) { response.setStatus(statusCode); } protected DefaultHttpResult(); @Inject DefaultHttpResult(HttpServletResponse response, Status status); @Override HttpResult addDateHeader(String name, long date); @Override HttpResult addHeader(String name, String value); @Override HttpResult addIntHeader(String name, int value); @Override void sendError(int statusCode); @Override void sendError(int statusCode, String message); @Override void setStatusCode(int statusCode); void movedPermanentlyTo(String uri); T movedPermanentlyTo(final Class<T> controller); @Override HttpResult body(String body); @Override HttpResult body(InputStream body); @Override HttpResult body(Reader body); } |
@Test public void shouldWriteStringBody() throws Exception { PrintWriter writer = mock(PrintWriter.class); when(response.getWriter()).thenReturn(writer); httpResult.body("The text"); verify(writer).print(anyString()); } | @Override public HttpResult body(String body) { try { response.getWriter().print(body); } catch (IOException e) { throw new ResultException("Couldn't write to response body", e); } return this; } | DefaultHttpResult implements HttpResult { @Override public HttpResult body(String body) { try { response.getWriter().print(body); } catch (IOException e) { throw new ResultException("Couldn't write to response body", e); } return this; } } | DefaultHttpResult implements HttpResult { @Override public HttpResult body(String body) { try { response.getWriter().print(body); } catch (IOException e) { throw new ResultException("Couldn't write to response body", e); } return this; } protected DefaultHttpResult(); @Inject DefaultHttpResult(HttpServletResponse response, Status status); } | DefaultHttpResult implements HttpResult { @Override public HttpResult body(String body) { try { response.getWriter().print(body); } catch (IOException e) { throw new ResultException("Couldn't write to response body", e); } return this; } protected DefaultHttpResult(); @Inject DefaultHttpResult(HttpServletResponse response, Status status); @Override HttpResult addDateHeader(String name, long date); @Override HttpResult addHeader(String name, String value); @Override HttpResult addIntHeader(String name, int value); @Override void sendError(int statusCode); @Override void sendError(int statusCode, String message); @Override void setStatusCode(int statusCode); void movedPermanentlyTo(String uri); T movedPermanentlyTo(final Class<T> controller); @Override HttpResult body(String body); @Override HttpResult body(InputStream body); @Override HttpResult body(Reader body); } | DefaultHttpResult implements HttpResult { @Override public HttpResult body(String body) { try { response.getWriter().print(body); } catch (IOException e) { throw new ResultException("Couldn't write to response body", e); } return this; } protected DefaultHttpResult(); @Inject DefaultHttpResult(HttpServletResponse response, Status status); @Override HttpResult addDateHeader(String name, long date); @Override HttpResult addHeader(String name, String value); @Override HttpResult addIntHeader(String name, int value); @Override void sendError(int statusCode); @Override void sendError(int statusCode, String message); @Override void setStatusCode(int statusCode); void movedPermanentlyTo(String uri); T movedPermanentlyTo(final Class<T> controller); @Override HttpResult body(String body); @Override HttpResult body(InputStream body); @Override HttpResult body(Reader body); } |
@Test public void shouldThrowResultExceptionIfAnIOExceptionWhenWriteStringBody() throws Exception { doThrow(new IOException()).when(response).getWriter(); try { httpResult.body("The text"); fail("should throw ResultException"); } catch (ResultException e) { } } | @Override public HttpResult body(String body) { try { response.getWriter().print(body); } catch (IOException e) { throw new ResultException("Couldn't write to response body", e); } return this; } | DefaultHttpResult implements HttpResult { @Override public HttpResult body(String body) { try { response.getWriter().print(body); } catch (IOException e) { throw new ResultException("Couldn't write to response body", e); } return this; } } | DefaultHttpResult implements HttpResult { @Override public HttpResult body(String body) { try { response.getWriter().print(body); } catch (IOException e) { throw new ResultException("Couldn't write to response body", e); } return this; } protected DefaultHttpResult(); @Inject DefaultHttpResult(HttpServletResponse response, Status status); } | DefaultHttpResult implements HttpResult { @Override public HttpResult body(String body) { try { response.getWriter().print(body); } catch (IOException e) { throw new ResultException("Couldn't write to response body", e); } return this; } protected DefaultHttpResult(); @Inject DefaultHttpResult(HttpServletResponse response, Status status); @Override HttpResult addDateHeader(String name, long date); @Override HttpResult addHeader(String name, String value); @Override HttpResult addIntHeader(String name, int value); @Override void sendError(int statusCode); @Override void sendError(int statusCode, String message); @Override void setStatusCode(int statusCode); void movedPermanentlyTo(String uri); T movedPermanentlyTo(final Class<T> controller); @Override HttpResult body(String body); @Override HttpResult body(InputStream body); @Override HttpResult body(Reader body); } | DefaultHttpResult implements HttpResult { @Override public HttpResult body(String body) { try { response.getWriter().print(body); } catch (IOException e) { throw new ResultException("Couldn't write to response body", e); } return this; } protected DefaultHttpResult(); @Inject DefaultHttpResult(HttpServletResponse response, Status status); @Override HttpResult addDateHeader(String name, long date); @Override HttpResult addHeader(String name, String value); @Override HttpResult addIntHeader(String name, int value); @Override void sendError(int statusCode); @Override void sendError(int statusCode, String message); @Override void setStatusCode(int statusCode); void movedPermanentlyTo(String uri); T movedPermanentlyTo(final Class<T> controller); @Override HttpResult body(String body); @Override HttpResult body(InputStream body); @Override HttpResult body(Reader body); } |
@Test public void shouldThrowResultExceptionIfAnIOExceptionWhenWriteInputStreamBody() throws Exception { doThrow(new IOException()).when(response).getOutputStream(); InputStream in = new ByteArrayInputStream("the text".getBytes()); try { httpResult.body(in); fail("should throw ResultException"); } catch (ResultException e) { } } | @Override public HttpResult body(String body) { try { response.getWriter().print(body); } catch (IOException e) { throw new ResultException("Couldn't write to response body", e); } return this; } | DefaultHttpResult implements HttpResult { @Override public HttpResult body(String body) { try { response.getWriter().print(body); } catch (IOException e) { throw new ResultException("Couldn't write to response body", e); } return this; } } | DefaultHttpResult implements HttpResult { @Override public HttpResult body(String body) { try { response.getWriter().print(body); } catch (IOException e) { throw new ResultException("Couldn't write to response body", e); } return this; } protected DefaultHttpResult(); @Inject DefaultHttpResult(HttpServletResponse response, Status status); } | DefaultHttpResult implements HttpResult { @Override public HttpResult body(String body) { try { response.getWriter().print(body); } catch (IOException e) { throw new ResultException("Couldn't write to response body", e); } return this; } protected DefaultHttpResult(); @Inject DefaultHttpResult(HttpServletResponse response, Status status); @Override HttpResult addDateHeader(String name, long date); @Override HttpResult addHeader(String name, String value); @Override HttpResult addIntHeader(String name, int value); @Override void sendError(int statusCode); @Override void sendError(int statusCode, String message); @Override void setStatusCode(int statusCode); void movedPermanentlyTo(String uri); T movedPermanentlyTo(final Class<T> controller); @Override HttpResult body(String body); @Override HttpResult body(InputStream body); @Override HttpResult body(Reader body); } | DefaultHttpResult implements HttpResult { @Override public HttpResult body(String body) { try { response.getWriter().print(body); } catch (IOException e) { throw new ResultException("Couldn't write to response body", e); } return this; } protected DefaultHttpResult(); @Inject DefaultHttpResult(HttpServletResponse response, Status status); @Override HttpResult addDateHeader(String name, long date); @Override HttpResult addHeader(String name, String value); @Override HttpResult addIntHeader(String name, int value); @Override void sendError(int statusCode); @Override void sendError(int statusCode, String message); @Override void setStatusCode(int statusCode); void movedPermanentlyTo(String uri); T movedPermanentlyTo(final Class<T> controller); @Override HttpResult body(String body); @Override HttpResult body(InputStream body); @Override HttpResult body(Reader body); } |
@Test public void shouldThrowResultExceptionIfAnIOExceptionWhenWriteReaderBody() throws Exception { doThrow(new IOException()).when(response).getWriter(); Reader reader = new StringReader("the text"); try { httpResult.body(reader); fail("should throw ResultException"); } catch (ResultException e) { } } | @Override public HttpResult body(String body) { try { response.getWriter().print(body); } catch (IOException e) { throw new ResultException("Couldn't write to response body", e); } return this; } | DefaultHttpResult implements HttpResult { @Override public HttpResult body(String body) { try { response.getWriter().print(body); } catch (IOException e) { throw new ResultException("Couldn't write to response body", e); } return this; } } | DefaultHttpResult implements HttpResult { @Override public HttpResult body(String body) { try { response.getWriter().print(body); } catch (IOException e) { throw new ResultException("Couldn't write to response body", e); } return this; } protected DefaultHttpResult(); @Inject DefaultHttpResult(HttpServletResponse response, Status status); } | DefaultHttpResult implements HttpResult { @Override public HttpResult body(String body) { try { response.getWriter().print(body); } catch (IOException e) { throw new ResultException("Couldn't write to response body", e); } return this; } protected DefaultHttpResult(); @Inject DefaultHttpResult(HttpServletResponse response, Status status); @Override HttpResult addDateHeader(String name, long date); @Override HttpResult addHeader(String name, String value); @Override HttpResult addIntHeader(String name, int value); @Override void sendError(int statusCode); @Override void sendError(int statusCode, String message); @Override void setStatusCode(int statusCode); void movedPermanentlyTo(String uri); T movedPermanentlyTo(final Class<T> controller); @Override HttpResult body(String body); @Override HttpResult body(InputStream body); @Override HttpResult body(Reader body); } | DefaultHttpResult implements HttpResult { @Override public HttpResult body(String body) { try { response.getWriter().print(body); } catch (IOException e) { throw new ResultException("Couldn't write to response body", e); } return this; } protected DefaultHttpResult(); @Inject DefaultHttpResult(HttpServletResponse response, Status status); @Override HttpResult addDateHeader(String name, long date); @Override HttpResult addHeader(String name, String value); @Override HttpResult addIntHeader(String name, int value); @Override void sendError(int statusCode); @Override void sendError(int statusCode, String message); @Override void setStatusCode(int statusCode); void movedPermanentlyTo(String uri); T movedPermanentlyTo(final Class<T> controller); @Override HttpResult body(String body); @Override HttpResult body(InputStream body); @Override HttpResult body(Reader body); } |
@Test public void whenThereIsNoRefererShouldThrowExceptionOnForward() throws Exception { when(request.getHeader("Referer")).thenReturn(null); try { refererResult.forward(); fail("Expected IllegalStateException"); } catch (IllegalStateException e) { } } | @Override public void forward() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).forwardTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).forwardTo(referer); } } | DefaultRefererResult implements RefererResult { @Override public void forward() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).forwardTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).forwardTo(referer); } } } | DefaultRefererResult implements RefererResult { @Override public void forward() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).forwardTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).forwardTo(referer); } } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); } | DefaultRefererResult implements RefererResult { @Override public void forward() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).forwardTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).forwardTo(referer); } } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); @Override void forward(); @Override void redirect(); } | DefaultRefererResult implements RefererResult { @Override public void forward() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).forwardTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).forwardTo(referer); } } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); @Override void forward(); @Override void redirect(); } |
@Test public void whenThereIsNoRefererShouldThrowExceptionOnRedirect() throws Exception { when(request.getHeader("Referer")).thenReturn(null); try { refererResult.redirect(); fail("Expected IllegalStateException"); } catch (IllegalStateException e) { } } | @Override public void redirect() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).redirectTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).redirectTo(referer); } } | DefaultRefererResult implements RefererResult { @Override public void redirect() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).redirectTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).redirectTo(referer); } } } | DefaultRefererResult implements RefererResult { @Override public void redirect() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).redirectTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).redirectTo(referer); } } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); } | DefaultRefererResult implements RefererResult { @Override public void redirect() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).redirectTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).redirectTo(referer); } } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); @Override void forward(); @Override void redirect(); } | DefaultRefererResult implements RefererResult { @Override public void redirect() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).redirectTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).redirectTo(referer); } } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); @Override void forward(); @Override void redirect(); } |
@Test public void whenRefererDontMatchAControllerShouldForwardToPage() throws Exception { PageResult page = mock(PageResult.class); when(request.getHeader("Referer")).thenReturn("http: when(request.getContextPath()).thenReturn("/vraptor"); when(router.parse("/no-controller", HttpMethod.GET, request)).thenThrow(new ControllerNotFoundException()); doReturn(page).when(result).use(page()); refererResult.forward(); verify(page).forwardTo("/no-controller"); } | @Override public void forward() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).forwardTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).forwardTo(referer); } } | DefaultRefererResult implements RefererResult { @Override public void forward() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).forwardTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).forwardTo(referer); } } } | DefaultRefererResult implements RefererResult { @Override public void forward() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).forwardTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).forwardTo(referer); } } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); } | DefaultRefererResult implements RefererResult { @Override public void forward() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).forwardTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).forwardTo(referer); } } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); @Override void forward(); @Override void redirect(); } | DefaultRefererResult implements RefererResult { @Override public void forward() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).forwardTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).forwardTo(referer); } } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); @Override void forward(); @Override void redirect(); } |
@Test public void whenRefererDontMatchAControllerShouldRedirectToPage() throws Exception { PageResult page = mock(PageResult.class); when(request.getHeader("Referer")).thenReturn("http: when(request.getContextPath()).thenReturn("/vraptor"); when(router.parse("/no-controller", HttpMethod.GET, request)).thenThrow(new ControllerNotFoundException()); doReturn(page).when(result).use(page()); refererResult.redirect(); verify(page).redirectTo("/no-controller"); } | @Override public void redirect() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).redirectTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).redirectTo(referer); } } | DefaultRefererResult implements RefererResult { @Override public void redirect() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).redirectTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).redirectTo(referer); } } } | DefaultRefererResult implements RefererResult { @Override public void redirect() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).redirectTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).redirectTo(referer); } } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); } | DefaultRefererResult implements RefererResult { @Override public void redirect() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).redirectTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).redirectTo(referer); } } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); @Override void forward(); @Override void redirect(); } | DefaultRefererResult implements RefererResult { @Override public void redirect() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).redirectTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).redirectTo(referer); } } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); @Override void forward(); @Override void redirect(); } |
@Test public void whenRefererMatchesAControllerShouldRedirectToIt() throws Exception { LogicResult logic = mock(LogicResult.class); RefererController controller = mock(RefererController.class); Method index = RefererController.class.getMethod("index"); ControllerMethod method = DefaultControllerMethod.instanceFor(RefererController.class, index); when(request.getHeader("Referer")).thenReturn("http: when(request.getContextPath()).thenReturn("/vraptor"); when(router.parse("/no-controller", HttpMethod.GET, request)).thenReturn(method); doReturn(logic).when(result).use(logic()); when(logic.redirectTo(RefererController.class)).thenReturn(controller); refererResult.redirect(); verify(logic).redirectTo(RefererController.class); verify(controller).index(); } | @Override public void redirect() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).redirectTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).redirectTo(referer); } } | DefaultRefererResult implements RefererResult { @Override public void redirect() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).redirectTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).redirectTo(referer); } } } | DefaultRefererResult implements RefererResult { @Override public void redirect() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).redirectTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).redirectTo(referer); } } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); } | DefaultRefererResult implements RefererResult { @Override public void redirect() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).redirectTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).redirectTo(referer); } } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); @Override void forward(); @Override void redirect(); } | DefaultRefererResult implements RefererResult { @Override public void redirect() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).redirectTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).redirectTo(referer); } } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); @Override void forward(); @Override void redirect(); } |
@Test public void findsTheCorrectAnnotatedMethodIfThereIsNoWebMethodAnnotationPresent() throws Exception { List<Route> routes = parser.rulesFor(new DefaultBeanClass(ClientsController.class)); Route route = getRouteMatching(routes, "/clients"); assertThat(route, canHandle(ClientsController.class, "list")); } | @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); } |
@Test public void whenRefererMatchesAControllerShouldForwardToIt() throws Exception { LogicResult logic = mock(LogicResult.class); RefererController controller = mock(RefererController.class); Method index = RefererController.class.getMethod("index"); ControllerMethod method = DefaultControllerMethod.instanceFor(RefererController.class, index); when(request.getHeader("Referer")).thenReturn("http: when(request.getContextPath()).thenReturn("/vraptor"); when(router.parse("/no-controller", HttpMethod.GET, request)).thenReturn(method); doReturn(logic).when(result).use(logic()); when(logic.forwardTo(RefererController.class)).thenReturn(controller); refererResult.forward(); verify(logic).forwardTo(RefererController.class); verify(controller).index(); } | @Override public void forward() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).forwardTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).forwardTo(referer); } } | DefaultRefererResult implements RefererResult { @Override public void forward() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).forwardTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).forwardTo(referer); } } } | DefaultRefererResult implements RefererResult { @Override public void forward() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).forwardTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).forwardTo(referer); } } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); } | DefaultRefererResult implements RefererResult { @Override public void forward() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).forwardTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).forwardTo(referer); } } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); @Override void forward(); @Override void redirect(); } | DefaultRefererResult implements RefererResult { @Override public void forward() throws IllegalStateException { String referer = getReferer(); try { ControllerMethod method = router.parse(referer, HttpMethod.GET, request); executeMethod(method, result.use(logic()).forwardTo(method.getController().getType())); } catch (ControllerNotFoundException | MethodNotAllowedException e) { logger.warn("Could not find or doesn't allowed to get controller method", e); result.use(page()).forwardTo(referer); } } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); @Override void forward(); @Override void redirect(); } |
@Test public void whenCtxPathAppearsInItsPlaceRefererShouldBeReturnedCorrectly() throws Exception { when(request.getHeader("Referer")).thenReturn("http: when(request.getContextPath()).thenReturn("/test"); assertEquals("/anything/ok", refererResult.getReferer()); } | protected String getReferer() { String referer = request.getHeader("Referer"); checkState(referer != null, "The Referer header was not specified"); String refererPath = null; try { refererPath = new URL(referer).getPath(); } catch(MalformedURLException e) { refererPath = referer; } String ctxPath = request.getContextPath(); return refererPath.startsWith(ctxPath+"/") || refererPath.equals(ctxPath) ? refererPath.substring(ctxPath.length()) : refererPath; } | DefaultRefererResult implements RefererResult { protected String getReferer() { String referer = request.getHeader("Referer"); checkState(referer != null, "The Referer header was not specified"); String refererPath = null; try { refererPath = new URL(referer).getPath(); } catch(MalformedURLException e) { refererPath = referer; } String ctxPath = request.getContextPath(); return refererPath.startsWith(ctxPath+"/") || refererPath.equals(ctxPath) ? refererPath.substring(ctxPath.length()) : refererPath; } } | DefaultRefererResult implements RefererResult { protected String getReferer() { String referer = request.getHeader("Referer"); checkState(referer != null, "The Referer header was not specified"); String refererPath = null; try { refererPath = new URL(referer).getPath(); } catch(MalformedURLException e) { refererPath = referer; } String ctxPath = request.getContextPath(); return refererPath.startsWith(ctxPath+"/") || refererPath.equals(ctxPath) ? refererPath.substring(ctxPath.length()) : refererPath; } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); } | DefaultRefererResult implements RefererResult { protected String getReferer() { String referer = request.getHeader("Referer"); checkState(referer != null, "The Referer header was not specified"); String refererPath = null; try { refererPath = new URL(referer).getPath(); } catch(MalformedURLException e) { refererPath = referer; } String ctxPath = request.getContextPath(); return refererPath.startsWith(ctxPath+"/") || refererPath.equals(ctxPath) ? refererPath.substring(ctxPath.length()) : refererPath; } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); @Override void forward(); @Override void redirect(); } | DefaultRefererResult implements RefererResult { protected String getReferer() { String referer = request.getHeader("Referer"); checkState(referer != null, "The Referer header was not specified"); String refererPath = null; try { refererPath = new URL(referer).getPath(); } catch(MalformedURLException e) { refererPath = referer; } String ctxPath = request.getContextPath(); return refererPath.startsWith(ctxPath+"/") || refererPath.equals(ctxPath) ? refererPath.substring(ctxPath.length()) : refererPath; } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); @Override void forward(); @Override void redirect(); } |
@Test public void whenCtxPathAppearsAmongURLButNotInRightPlaceRefererShouldBeReturnedCorrectly() throws Exception { when(request.getHeader("Referer")).thenReturn("http: when(request.getContextPath()).thenReturn("/vrap"); assertEquals("/vrapanything/ok/vrap/ok/vrap", refererResult.getReferer()); } | protected String getReferer() { String referer = request.getHeader("Referer"); checkState(referer != null, "The Referer header was not specified"); String refererPath = null; try { refererPath = new URL(referer).getPath(); } catch(MalformedURLException e) { refererPath = referer; } String ctxPath = request.getContextPath(); return refererPath.startsWith(ctxPath+"/") || refererPath.equals(ctxPath) ? refererPath.substring(ctxPath.length()) : refererPath; } | DefaultRefererResult implements RefererResult { protected String getReferer() { String referer = request.getHeader("Referer"); checkState(referer != null, "The Referer header was not specified"); String refererPath = null; try { refererPath = new URL(referer).getPath(); } catch(MalformedURLException e) { refererPath = referer; } String ctxPath = request.getContextPath(); return refererPath.startsWith(ctxPath+"/") || refererPath.equals(ctxPath) ? refererPath.substring(ctxPath.length()) : refererPath; } } | DefaultRefererResult implements RefererResult { protected String getReferer() { String referer = request.getHeader("Referer"); checkState(referer != null, "The Referer header was not specified"); String refererPath = null; try { refererPath = new URL(referer).getPath(); } catch(MalformedURLException e) { refererPath = referer; } String ctxPath = request.getContextPath(); return refererPath.startsWith(ctxPath+"/") || refererPath.equals(ctxPath) ? refererPath.substring(ctxPath.length()) : refererPath; } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); } | DefaultRefererResult implements RefererResult { protected String getReferer() { String referer = request.getHeader("Referer"); checkState(referer != null, "The Referer header was not specified"); String refererPath = null; try { refererPath = new URL(referer).getPath(); } catch(MalformedURLException e) { refererPath = referer; } String ctxPath = request.getContextPath(); return refererPath.startsWith(ctxPath+"/") || refererPath.equals(ctxPath) ? refererPath.substring(ctxPath.length()) : refererPath; } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); @Override void forward(); @Override void redirect(); } | DefaultRefererResult implements RefererResult { protected String getReferer() { String referer = request.getHeader("Referer"); checkState(referer != null, "The Referer header was not specified"); String refererPath = null; try { refererPath = new URL(referer).getPath(); } catch(MalformedURLException e) { refererPath = referer; } String ctxPath = request.getContextPath(); return refererPath.startsWith(ctxPath+"/") || refererPath.equals(ctxPath) ? refererPath.substring(ctxPath.length()) : refererPath; } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); @Override void forward(); @Override void redirect(); } |
@Test public void whenCtxPathEqualsURLPathRefererShouldBeReturnedCorrectly() throws Exception { when(request.getHeader("Referer")).thenReturn("http: when(request.getContextPath()).thenReturn("/vrap"); assertEquals("/", refererResult.getReferer()); } | protected String getReferer() { String referer = request.getHeader("Referer"); checkState(referer != null, "The Referer header was not specified"); String refererPath = null; try { refererPath = new URL(referer).getPath(); } catch(MalformedURLException e) { refererPath = referer; } String ctxPath = request.getContextPath(); return refererPath.startsWith(ctxPath+"/") || refererPath.equals(ctxPath) ? refererPath.substring(ctxPath.length()) : refererPath; } | DefaultRefererResult implements RefererResult { protected String getReferer() { String referer = request.getHeader("Referer"); checkState(referer != null, "The Referer header was not specified"); String refererPath = null; try { refererPath = new URL(referer).getPath(); } catch(MalformedURLException e) { refererPath = referer; } String ctxPath = request.getContextPath(); return refererPath.startsWith(ctxPath+"/") || refererPath.equals(ctxPath) ? refererPath.substring(ctxPath.length()) : refererPath; } } | DefaultRefererResult implements RefererResult { protected String getReferer() { String referer = request.getHeader("Referer"); checkState(referer != null, "The Referer header was not specified"); String refererPath = null; try { refererPath = new URL(referer).getPath(); } catch(MalformedURLException e) { refererPath = referer; } String ctxPath = request.getContextPath(); return refererPath.startsWith(ctxPath+"/") || refererPath.equals(ctxPath) ? refererPath.substring(ctxPath.length()) : refererPath; } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); } | DefaultRefererResult implements RefererResult { protected String getReferer() { String referer = request.getHeader("Referer"); checkState(referer != null, "The Referer header was not specified"); String refererPath = null; try { refererPath = new URL(referer).getPath(); } catch(MalformedURLException e) { refererPath = referer; } String ctxPath = request.getContextPath(); return refererPath.startsWith(ctxPath+"/") || refererPath.equals(ctxPath) ? refererPath.substring(ctxPath.length()) : refererPath; } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); @Override void forward(); @Override void redirect(); } | DefaultRefererResult implements RefererResult { protected String getReferer() { String referer = request.getHeader("Referer"); checkState(referer != null, "The Referer header was not specified"); String refererPath = null; try { refererPath = new URL(referer).getPath(); } catch(MalformedURLException e) { refererPath = referer; } String ctxPath = request.getContextPath(); return refererPath.startsWith(ctxPath+"/") || refererPath.equals(ctxPath) ? refererPath.substring(ctxPath.length()) : refererPath; } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); @Override void forward(); @Override void redirect(); } |
@Test public void whenRefererIsARelativePathRefererShouldBeReturnedCorrectly() throws Exception { when(request.getHeader("Referer")).thenReturn("/vrap/anything/ok/vrap"); when(request.getContextPath()).thenReturn("/vrap"); assertEquals("/anything/ok/vrap", refererResult.getReferer()); } | protected String getReferer() { String referer = request.getHeader("Referer"); checkState(referer != null, "The Referer header was not specified"); String refererPath = null; try { refererPath = new URL(referer).getPath(); } catch(MalformedURLException e) { refererPath = referer; } String ctxPath = request.getContextPath(); return refererPath.startsWith(ctxPath+"/") || refererPath.equals(ctxPath) ? refererPath.substring(ctxPath.length()) : refererPath; } | DefaultRefererResult implements RefererResult { protected String getReferer() { String referer = request.getHeader("Referer"); checkState(referer != null, "The Referer header was not specified"); String refererPath = null; try { refererPath = new URL(referer).getPath(); } catch(MalformedURLException e) { refererPath = referer; } String ctxPath = request.getContextPath(); return refererPath.startsWith(ctxPath+"/") || refererPath.equals(ctxPath) ? refererPath.substring(ctxPath.length()) : refererPath; } } | DefaultRefererResult implements RefererResult { protected String getReferer() { String referer = request.getHeader("Referer"); checkState(referer != null, "The Referer header was not specified"); String refererPath = null; try { refererPath = new URL(referer).getPath(); } catch(MalformedURLException e) { refererPath = referer; } String ctxPath = request.getContextPath(); return refererPath.startsWith(ctxPath+"/") || refererPath.equals(ctxPath) ? refererPath.substring(ctxPath.length()) : refererPath; } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); } | DefaultRefererResult implements RefererResult { protected String getReferer() { String referer = request.getHeader("Referer"); checkState(referer != null, "The Referer header was not specified"); String refererPath = null; try { refererPath = new URL(referer).getPath(); } catch(MalformedURLException e) { refererPath = referer; } String ctxPath = request.getContextPath(); return refererPath.startsWith(ctxPath+"/") || refererPath.equals(ctxPath) ? refererPath.substring(ctxPath.length()) : refererPath; } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); @Override void forward(); @Override void redirect(); } | DefaultRefererResult implements RefererResult { protected String getReferer() { String referer = request.getHeader("Referer"); checkState(referer != null, "The Referer header was not specified"); String refererPath = null; try { refererPath = new URL(referer).getPath(); } catch(MalformedURLException e) { refererPath = referer; } String ctxPath = request.getContextPath(); return refererPath.startsWith(ctxPath+"/") || refererPath.equals(ctxPath) ? refererPath.substring(ctxPath.length()) : refererPath; } protected DefaultRefererResult(); @Inject DefaultRefererResult(Result result, MutableRequest request, Router router, ParametersProvider provider,
ReflectionProvider reflectionProvider); @Override void forward(); @Override void redirect(); } |
@Test public void shouldCreateComponentsWithCache(){ UsingCacheComponent component = cdiBasedContainer.instanceFor(UsingCacheComponent.class); component.putWithLRU("test","test"); component.putWithDefault("test2","test2"); assertEquals(component.putWithLRU("test","test"),"test"); assertEquals(component.putWithDefault("test2","test2"),"test2"); } | @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } protected CDIBasedContainer(); @Inject CDIBasedContainer(BeanManager beanManager); } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } protected CDIBasedContainer(); @Inject CDIBasedContainer(BeanManager beanManager); @Override @SuppressWarnings("unchecked") T instanceFor(Class<T> type); @Override @SuppressWarnings("unchecked") boolean canProvide(Class<T> type); } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } protected CDIBasedContainer(); @Inject CDIBasedContainer(BeanManager beanManager); @Override @SuppressWarnings("unchecked") T instanceFor(Class<T> type); @Override @SuppressWarnings("unchecked") boolean canProvide(Class<T> type); } |
@Test public void shoudRegisterResourcesInRouter() { initEvent.fire(new VRaptorInitialized(null)); Router router = instanceFor(Router.class); Matcher<Iterable<? super Route>> hasItem = hasItem(canHandle(ControllerInTheClasspath.class, ControllerInTheClasspath.class.getDeclaredMethods()[0])); assertThat(router.allRoutes(), hasItem); } | @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } protected CDIBasedContainer(); @Inject CDIBasedContainer(BeanManager beanManager); } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } protected CDIBasedContainer(); @Inject CDIBasedContainer(BeanManager beanManager); @Override @SuppressWarnings("unchecked") T instanceFor(Class<T> type); @Override @SuppressWarnings("unchecked") boolean canProvide(Class<T> type); } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } protected CDIBasedContainer(); @Inject CDIBasedContainer(BeanManager beanManager); @Override @SuppressWarnings("unchecked") T instanceFor(Class<T> type); @Override @SuppressWarnings("unchecked") boolean canProvide(Class<T> type); } |
@Test public void shoudRegisterConvertersInConverters() { Converters converters = instanceFor(Converters.class); Converter<?> converter = converters.to(Void.class); assertThat(converter, is(instanceOf(ConverterInTheClasspath.class))); } | @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } protected CDIBasedContainer(); @Inject CDIBasedContainer(BeanManager beanManager); } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } protected CDIBasedContainer(); @Inject CDIBasedContainer(BeanManager beanManager); @Override @SuppressWarnings("unchecked") T instanceFor(Class<T> type); @Override @SuppressWarnings("unchecked") boolean canProvide(Class<T> type); } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } protected CDIBasedContainer(); @Inject CDIBasedContainer(BeanManager beanManager); @Override @SuppressWarnings("unchecked") T instanceFor(Class<T> type); @Override @SuppressWarnings("unchecked") boolean canProvide(Class<T> type); } |
@Test public void shouldReturnAllDefaultDeserializers() { Deserializers deserializers = instanceFor(Deserializers.class); List<String> types = asList("application/json", "json", "application/xml", "xml", "text/xml", "application/x-www-form-urlencoded"); for (String type : types) { assertThat("deserializer not found: " + type, deserializers.deserializerFor(type, cdiBasedContainer), is(notNullValue())); } } | @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } protected CDIBasedContainer(); @Inject CDIBasedContainer(BeanManager beanManager); } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } protected CDIBasedContainer(); @Inject CDIBasedContainer(BeanManager beanManager); @Override @SuppressWarnings("unchecked") T instanceFor(Class<T> type); @Override @SuppressWarnings("unchecked") boolean canProvide(Class<T> type); } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } protected CDIBasedContainer(); @Inject CDIBasedContainer(BeanManager beanManager); @Override @SuppressWarnings("unchecked") T instanceFor(Class<T> type); @Override @SuppressWarnings("unchecked") boolean canProvide(Class<T> type); } |
@Test public void shouldReturnAllDefaultConverters() { Converters converters = instanceFor(Converters.class); final HashMap<Class<?>, Class<?>> EXPECTED_CONVERTERS = new HashMap<Class<?>, Class<?>>() { { put(int.class, PrimitiveIntConverter.class); put(long.class, PrimitiveLongConverter.class); put(short.class, PrimitiveShortConverter.class); put(byte.class, PrimitiveByteConverter.class); put(double.class, PrimitiveDoubleConverter.class); put(float.class, PrimitiveFloatConverter.class); put(boolean.class, PrimitiveBooleanConverter.class); put(Integer.class, IntegerConverter.class); put(Long.class, LongConverter.class); put(Short.class, ShortConverter.class); put(Byte.class, ByteConverter.class); put(Double.class, DoubleConverter.class); put(Float.class, FloatConverter.class); put(Boolean.class, BooleanConverter.class); put(Calendar.class, CalendarConverter.class); put(Date.class, DateConverter.class); put(Enum.class, EnumConverter.class); } private static final long serialVersionUID = 8559316558416038474L; }; for (Entry<Class<?>, Class<?>> entry : EXPECTED_CONVERTERS.entrySet()) { Converter<?> converter = converters.to((Class<?>) entry.getKey()); assertThat(converter, is(instanceOf(entry.getValue()))); } } | @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } protected CDIBasedContainer(); @Inject CDIBasedContainer(BeanManager beanManager); } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } protected CDIBasedContainer(); @Inject CDIBasedContainer(BeanManager beanManager); @Override @SuppressWarnings("unchecked") T instanceFor(Class<T> type); @Override @SuppressWarnings("unchecked") boolean canProvide(Class<T> type); } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } protected CDIBasedContainer(); @Inject CDIBasedContainer(BeanManager beanManager); @Override @SuppressWarnings("unchecked") T instanceFor(Class<T> type); @Override @SuppressWarnings("unchecked") boolean canProvide(Class<T> type); } |
@Test public void suportsTheDefaultNameForANonAnnotatedMethod() throws SecurityException, NoSuchMethodException { List<Route> routes = parser.rulesFor(new DefaultBeanClass(ClientsController.class)); Route route = getRouteMatching(routes, "/clients/add"); assertThat(route, canHandle(ClientsController.class, "add")); } | @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); } |
@Test public void shoudRegisterInterceptorsInInterceptorRegistry() { InterceptorRegistry registry = instanceFor(InterceptorRegistry.class); assertThat(registry.all(), hasOneCopyOf(InterceptorInTheClasspath.class)); } | @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } protected CDIBasedContainer(); @Inject CDIBasedContainer(BeanManager beanManager); } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } protected CDIBasedContainer(); @Inject CDIBasedContainer(BeanManager beanManager); @Override @SuppressWarnings("unchecked") T instanceFor(Class<T> type); @Override @SuppressWarnings("unchecked") boolean canProvide(Class<T> type); } | CDIBasedContainer implements Container { @Override @SuppressWarnings("unchecked") public <T> T instanceFor(Class<T> type) { type = (Class<T>) CDIProxies.extractRawTypeIfPossible(type); logger.debug("asking cdi to get instance for {}", type); Bean<?> bean = getBeanFrom(type); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, type, ctx); } protected CDIBasedContainer(); @Inject CDIBasedContainer(BeanManager beanManager); @Override @SuppressWarnings("unchecked") T instanceFor(Class<T> type); @Override @SuppressWarnings("unchecked") boolean canProvide(Class<T> type); } |
@Test public void shouldRegisterInterceptorsOnRegistry() throws Exception { handler.handle(new DefaultBeanClass(InterceptorA.class)); verify(interceptorRegistry, times(1)).register(InterceptorA.class); } | public void handle(@Observes @InterceptsQualifier BeanClass beanClass) { Class<?> originalType = beanClass.getType(); interceptorValidator.validate(originalType); logger.debug("Found interceptor for {}", originalType); registry.register(originalType); } | InterceptorStereotypeHandler { public void handle(@Observes @InterceptsQualifier BeanClass beanClass) { Class<?> originalType = beanClass.getType(); interceptorValidator.validate(originalType); logger.debug("Found interceptor for {}", originalType); registry.register(originalType); } } | InterceptorStereotypeHandler { public void handle(@Observes @InterceptsQualifier BeanClass beanClass) { Class<?> originalType = beanClass.getType(); interceptorValidator.validate(originalType); logger.debug("Found interceptor for {}", originalType); registry.register(originalType); } protected InterceptorStereotypeHandler(); @Inject InterceptorStereotypeHandler(InterceptorRegistry registry, InterceptorValidator validator); } | InterceptorStereotypeHandler { public void handle(@Observes @InterceptsQualifier BeanClass beanClass) { Class<?> originalType = beanClass.getType(); interceptorValidator.validate(originalType); logger.debug("Found interceptor for {}", originalType); registry.register(originalType); } protected InterceptorStereotypeHandler(); @Inject InterceptorStereotypeHandler(InterceptorRegistry registry, InterceptorValidator validator); void handle(@Observes @InterceptsQualifier BeanClass beanClass); } | InterceptorStereotypeHandler { public void handle(@Observes @InterceptsQualifier BeanClass beanClass) { Class<?> originalType = beanClass.getType(); interceptorValidator.validate(originalType); logger.debug("Found interceptor for {}", originalType); registry.register(originalType); } protected InterceptorStereotypeHandler(); @Inject InterceptorStereotypeHandler(InterceptorRegistry registry, InterceptorValidator validator); void handle(@Observes @InterceptsQualifier BeanClass beanClass); } |
@Test public void shouldUseContainerForNewView() { final MyView expectedView = new MyView(); when(container.instanceFor(MyView.class)).thenReturn(expectedView); MyView view = result.use(MyView.class); assertThat(view, is(expectedView)); } | @Override public <T extends View> T use(Class<T> view) { messages.assertAbsenceOfErrors(); responseCommitted = true; return container.instanceFor(view); } | DefaultResult extends AbstractResult { @Override public <T extends View> T use(Class<T> view) { messages.assertAbsenceOfErrors(); responseCommitted = true; return container.instanceFor(view); } } | DefaultResult extends AbstractResult { @Override public <T extends View> T use(Class<T> view) { messages.assertAbsenceOfErrors(); responseCommitted = true; return container.instanceFor(view); } protected DefaultResult(); @Inject DefaultResult(HttpServletRequest request, Container container, ExceptionMapper exceptions, TypeNameExtractor extractor,
Messages messages); } | DefaultResult extends AbstractResult { @Override public <T extends View> T use(Class<T> view) { messages.assertAbsenceOfErrors(); responseCommitted = true; return container.instanceFor(view); } protected DefaultResult(); @Inject DefaultResult(HttpServletRequest request, Container container, ExceptionMapper exceptions, TypeNameExtractor extractor,
Messages messages); @Override T use(Class<T> view); @Override Result on(Class<? extends Exception> exception); @Override Result include(String key, Object value); @Override boolean used(); @Override Map<String, Object> included(); @Override Result include(Object value); } | DefaultResult extends AbstractResult { @Override public <T extends View> T use(Class<T> view) { messages.assertAbsenceOfErrors(); responseCommitted = true; return container.instanceFor(view); } protected DefaultResult(); @Inject DefaultResult(HttpServletRequest request, Container container, ExceptionMapper exceptions, TypeNameExtractor extractor,
Messages messages); @Override T use(Class<T> view); @Override Result on(Class<? extends Exception> exception); @Override Result include(String key, Object value); @Override boolean used(); @Override Map<String, Object> included(); @Override Result include(Object value); } |
@Test public void shouldSetRequestAttribute() { result.include("my_key", "my_value"); verify(request).setAttribute("my_key", "my_value"); } | @Override public Result include(String key, Object value) { logger.debug("including attribute {}: {}", key, value); includedAttributes.put(key, value); request.setAttribute(key, value); return this; } | DefaultResult extends AbstractResult { @Override public Result include(String key, Object value) { logger.debug("including attribute {}: {}", key, value); includedAttributes.put(key, value); request.setAttribute(key, value); return this; } } | DefaultResult extends AbstractResult { @Override public Result include(String key, Object value) { logger.debug("including attribute {}: {}", key, value); includedAttributes.put(key, value); request.setAttribute(key, value); return this; } protected DefaultResult(); @Inject DefaultResult(HttpServletRequest request, Container container, ExceptionMapper exceptions, TypeNameExtractor extractor,
Messages messages); } | DefaultResult extends AbstractResult { @Override public Result include(String key, Object value) { logger.debug("including attribute {}: {}", key, value); includedAttributes.put(key, value); request.setAttribute(key, value); return this; } protected DefaultResult(); @Inject DefaultResult(HttpServletRequest request, Container container, ExceptionMapper exceptions, TypeNameExtractor extractor,
Messages messages); @Override T use(Class<T> view); @Override Result on(Class<? extends Exception> exception); @Override Result include(String key, Object value); @Override boolean used(); @Override Map<String, Object> included(); @Override Result include(Object value); } | DefaultResult extends AbstractResult { @Override public Result include(String key, Object value) { logger.debug("including attribute {}: {}", key, value); includedAttributes.put(key, value); request.setAttribute(key, value); return this; } protected DefaultResult(); @Inject DefaultResult(HttpServletRequest request, Container container, ExceptionMapper exceptions, TypeNameExtractor extractor,
Messages messages); @Override T use(Class<T> view); @Override Result on(Class<? extends Exception> exception); @Override Result include(String key, Object value); @Override boolean used(); @Override Map<String, Object> included(); @Override Result include(Object value); } |
@Test public void shouldCallAssertAbsenceOfErrorsMethodFromMessages() throws Exception { result.use(Results.json()); verify(messages).assertAbsenceOfErrors(); } | @Override public <T extends View> T use(Class<T> view) { messages.assertAbsenceOfErrors(); responseCommitted = true; return container.instanceFor(view); } | DefaultResult extends AbstractResult { @Override public <T extends View> T use(Class<T> view) { messages.assertAbsenceOfErrors(); responseCommitted = true; return container.instanceFor(view); } } | DefaultResult extends AbstractResult { @Override public <T extends View> T use(Class<T> view) { messages.assertAbsenceOfErrors(); responseCommitted = true; return container.instanceFor(view); } protected DefaultResult(); @Inject DefaultResult(HttpServletRequest request, Container container, ExceptionMapper exceptions, TypeNameExtractor extractor,
Messages messages); } | DefaultResult extends AbstractResult { @Override public <T extends View> T use(Class<T> view) { messages.assertAbsenceOfErrors(); responseCommitted = true; return container.instanceFor(view); } protected DefaultResult(); @Inject DefaultResult(HttpServletRequest request, Container container, ExceptionMapper exceptions, TypeNameExtractor extractor,
Messages messages); @Override T use(Class<T> view); @Override Result on(Class<? extends Exception> exception); @Override Result include(String key, Object value); @Override boolean used(); @Override Map<String, Object> included(); @Override Result include(Object value); } | DefaultResult extends AbstractResult { @Override public <T extends View> T use(Class<T> view) { messages.assertAbsenceOfErrors(); responseCommitted = true; return container.instanceFor(view); } protected DefaultResult(); @Inject DefaultResult(HttpServletRequest request, Container container, ExceptionMapper exceptions, TypeNameExtractor extractor,
Messages messages); @Override T use(Class<T> view); @Override Result on(Class<? extends Exception> exception); @Override Result include(String key, Object value); @Override boolean used(); @Override Map<String, Object> included(); @Override Result include(Object value); } |
@Test public void shouldIncludeExtractedNameWhenSimplyIncluding() throws Exception { Account account = new Account(); when(extractor.nameFor(Account.class)).thenReturn("account"); result.include(account); verify(request).setAttribute("account", account); } | @Override public Result include(String key, Object value) { logger.debug("including attribute {}: {}", key, value); includedAttributes.put(key, value); request.setAttribute(key, value); return this; } | DefaultResult extends AbstractResult { @Override public Result include(String key, Object value) { logger.debug("including attribute {}: {}", key, value); includedAttributes.put(key, value); request.setAttribute(key, value); return this; } } | DefaultResult extends AbstractResult { @Override public Result include(String key, Object value) { logger.debug("including attribute {}: {}", key, value); includedAttributes.put(key, value); request.setAttribute(key, value); return this; } protected DefaultResult(); @Inject DefaultResult(HttpServletRequest request, Container container, ExceptionMapper exceptions, TypeNameExtractor extractor,
Messages messages); } | DefaultResult extends AbstractResult { @Override public Result include(String key, Object value) { logger.debug("including attribute {}: {}", key, value); includedAttributes.put(key, value); request.setAttribute(key, value); return this; } protected DefaultResult(); @Inject DefaultResult(HttpServletRequest request, Container container, ExceptionMapper exceptions, TypeNameExtractor extractor,
Messages messages); @Override T use(Class<T> view); @Override Result on(Class<? extends Exception> exception); @Override Result include(String key, Object value); @Override boolean used(); @Override Map<String, Object> included(); @Override Result include(Object value); } | DefaultResult extends AbstractResult { @Override public Result include(String key, Object value) { logger.debug("including attribute {}: {}", key, value); includedAttributes.put(key, value); request.setAttribute(key, value); return this; } protected DefaultResult(); @Inject DefaultResult(HttpServletRequest request, Container container, ExceptionMapper exceptions, TypeNameExtractor extractor,
Messages messages); @Override T use(Class<T> view); @Override Result on(Class<? extends Exception> exception); @Override Result include(String key, Object value); @Override boolean used(); @Override Map<String, Object> included(); @Override Result include(Object value); } |
@Test public void shouldNotIncludeTheAttributeWhenTheValueIsNull() throws Exception { result.include(null); verify(request, never()).setAttribute(anyString(), anyObject()); } | @Override public Result include(String key, Object value) { logger.debug("including attribute {}: {}", key, value); includedAttributes.put(key, value); request.setAttribute(key, value); return this; } | DefaultResult extends AbstractResult { @Override public Result include(String key, Object value) { logger.debug("including attribute {}: {}", key, value); includedAttributes.put(key, value); request.setAttribute(key, value); return this; } } | DefaultResult extends AbstractResult { @Override public Result include(String key, Object value) { logger.debug("including attribute {}: {}", key, value); includedAttributes.put(key, value); request.setAttribute(key, value); return this; } protected DefaultResult(); @Inject DefaultResult(HttpServletRequest request, Container container, ExceptionMapper exceptions, TypeNameExtractor extractor,
Messages messages); } | DefaultResult extends AbstractResult { @Override public Result include(String key, Object value) { logger.debug("including attribute {}: {}", key, value); includedAttributes.put(key, value); request.setAttribute(key, value); return this; } protected DefaultResult(); @Inject DefaultResult(HttpServletRequest request, Container container, ExceptionMapper exceptions, TypeNameExtractor extractor,
Messages messages); @Override T use(Class<T> view); @Override Result on(Class<? extends Exception> exception); @Override Result include(String key, Object value); @Override boolean used(); @Override Map<String, Object> included(); @Override Result include(Object value); } | DefaultResult extends AbstractResult { @Override public Result include(String key, Object value) { logger.debug("including attribute {}: {}", key, value); includedAttributes.put(key, value); request.setAttribute(key, value); return this; } protected DefaultResult(); @Inject DefaultResult(HttpServletRequest request, Container container, ExceptionMapper exceptions, TypeNameExtractor extractor,
Messages messages); @Override T use(Class<T> view); @Override Result on(Class<? extends Exception> exception); @Override Result include(String key, Object value); @Override boolean used(); @Override Map<String, Object> included(); @Override Result include(Object value); } |
@Test public void shouldReturnHandlersListInTheSameOrderThatRegistry() { LinkedList<InterceptorHandler> handlers = cache.getInterceptorHandlers(); assertEquals(FirstInterceptor.class, extractInterceptor(handlers.get(0))); assertEquals(SecondInterceptor.class, extractInterceptor(handlers.get(1))); } | public LinkedList<InterceptorHandler> getInterceptorHandlers() { return new LinkedList<>(interceptorHandlers); } | InterceptorStackHandlersCache { public LinkedList<InterceptorHandler> getInterceptorHandlers() { return new LinkedList<>(interceptorHandlers); } } | InterceptorStackHandlersCache { public LinkedList<InterceptorHandler> getInterceptorHandlers() { return new LinkedList<>(interceptorHandlers); } protected InterceptorStackHandlersCache(); @Inject InterceptorStackHandlersCache(InterceptorRegistry registry, InterceptorHandlerFactory handlerFactory); } | InterceptorStackHandlersCache { public LinkedList<InterceptorHandler> getInterceptorHandlers() { return new LinkedList<>(interceptorHandlers); } protected InterceptorStackHandlersCache(); @Inject InterceptorStackHandlersCache(InterceptorRegistry registry, InterceptorHandlerFactory handlerFactory); void init(); LinkedList<InterceptorHandler> getInterceptorHandlers(); } | InterceptorStackHandlersCache { public LinkedList<InterceptorHandler> getInterceptorHandlers() { return new LinkedList<>(interceptorHandlers); } protected InterceptorStackHandlersCache(); @Inject InterceptorStackHandlersCache(InterceptorRegistry registry, InterceptorHandlerFactory handlerFactory); void init(); LinkedList<InterceptorHandler> getInterceptorHandlers(); } |
@Test public void cacheShouldBeImmutable() { cache.getInterceptorHandlers().remove(0); assertEquals(2, cache.getInterceptorHandlers().size()); } | public LinkedList<InterceptorHandler> getInterceptorHandlers() { return new LinkedList<>(interceptorHandlers); } | InterceptorStackHandlersCache { public LinkedList<InterceptorHandler> getInterceptorHandlers() { return new LinkedList<>(interceptorHandlers); } } | InterceptorStackHandlersCache { public LinkedList<InterceptorHandler> getInterceptorHandlers() { return new LinkedList<>(interceptorHandlers); } protected InterceptorStackHandlersCache(); @Inject InterceptorStackHandlersCache(InterceptorRegistry registry, InterceptorHandlerFactory handlerFactory); } | InterceptorStackHandlersCache { public LinkedList<InterceptorHandler> getInterceptorHandlers() { return new LinkedList<>(interceptorHandlers); } protected InterceptorStackHandlersCache(); @Inject InterceptorStackHandlersCache(InterceptorRegistry registry, InterceptorHandlerFactory handlerFactory); void init(); LinkedList<InterceptorHandler> getInterceptorHandlers(); } | InterceptorStackHandlersCache { public LinkedList<InterceptorHandler> getInterceptorHandlers() { return new LinkedList<>(interceptorHandlers); } protected InterceptorStackHandlersCache(); @Inject InterceptorStackHandlersCache(InterceptorRegistry registry, InterceptorHandlerFactory handlerFactory); void init(); LinkedList<InterceptorHandler> getInterceptorHandlers(); } |
@Test public void shouldGetLocaleFromRequestFirst() { when(request.getAttribute(FMT_LOCALE + ".request")).thenReturn(PT_BR); when(session.getAttribute(FMT_LOCALE + ".session")).thenReturn(Locale.ENGLISH); when(servletContext.getAttribute(FMT_LOCALE + ".application")).thenReturn(Locale.ENGLISH); when(servletContext.getInitParameter(Config.FMT_LOCALE)).thenReturn(Locale.ENGLISH.toString()); when(request.getLocale()).thenReturn(Locale.ENGLISH); assumeThat(Locale.getDefault(), is(Locale.ENGLISH)); assertThat(localization.getLocale(), equalTo(PT_BR)); } | @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); @Produces ResourceBundle getBundle(Locale locale); @Produces Locale getLocale(); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); @Produces ResourceBundle getBundle(Locale locale); @Produces Locale getLocale(); } |
@Test public void ignoresTheControllerSuffixForANonAnnotatedMethod() throws SecurityException, NoSuchMethodException { List<Route> routes = parser.rulesFor(new DefaultBeanClass(ClientsController.class)); Route route = getRouteMatching(routes, "/clients/add"); assertThat(route, canHandle(ClientsController.class, "add")); } | @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); } |
@Test public void shouldGetLocaleFromSessionWhenNotFoundInRequest() { when(session.getAttribute(FMT_LOCALE + ".session")).thenReturn(PT_BR); when(servletContext.getAttribute(FMT_LOCALE + ".application")).thenReturn(Locale.ENGLISH); when(servletContext.getInitParameter(Config.FMT_LOCALE)).thenReturn(Locale.ENGLISH.toString()); when(request.getLocale()).thenReturn(Locale.ENGLISH); assumeThat(Locale.getDefault(), is(Locale.ENGLISH)); assertThat(localization.getLocale(), equalTo(PT_BR)); } | @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); @Produces ResourceBundle getBundle(Locale locale); @Produces Locale getLocale(); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); @Produces ResourceBundle getBundle(Locale locale); @Produces Locale getLocale(); } |
@Test public void shouldGetLocaleFromServletContextWhenNotFoundInSession() { when(servletContext.getAttribute(FMT_LOCALE + ".application")).thenReturn(PT_BR); when(servletContext.getInitParameter(Config.FMT_LOCALE)).thenReturn(Locale.ENGLISH.toString()); when(request.getLocale()).thenReturn(Locale.ENGLISH); assumeThat(Locale.getDefault(), is(Locale.ENGLISH)); assertThat(localization.getLocale(), equalTo(PT_BR)); } | @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); @Produces ResourceBundle getBundle(Locale locale); @Produces Locale getLocale(); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); @Produces ResourceBundle getBundle(Locale locale); @Produces Locale getLocale(); } |
@Test public void shouldGetLocaleFromInitParameterWhenNotFoundInServletContext() { when(servletContext.getInitParameter(Config.FMT_LOCALE)).thenReturn(PT_BR.toString()); when(request.getLocale()).thenReturn(Locale.ENGLISH); assumeThat(Locale.getDefault(), is(Locale.ENGLISH)); assertThat(localization.getLocale(), equalTo(PT_BR)); } | @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); @Produces ResourceBundle getBundle(Locale locale); @Produces Locale getLocale(); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); @Produces ResourceBundle getBundle(Locale locale); @Produces Locale getLocale(); } |
@Test public void shouldGetLocaleFromRequestLocaleWhenNotFoundUnderAnyOtherScope() { when(request.getLocale()).thenReturn(PT_BR); assumeThat(Locale.getDefault(), is(Locale.ENGLISH)); assertThat(localization.getLocale(), equalTo(PT_BR)); } | @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); @Produces ResourceBundle getBundle(Locale locale); @Produces Locale getLocale(); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); @Produces ResourceBundle getBundle(Locale locale); @Produces Locale getLocale(); } |
@Test public void findLocaleFromDefaultWhenNotFoundInAnyOtherScope() { assumeThat(Locale.getDefault(), is(Locale.ENGLISH)); assertThat(localization.getLocale(), equalTo(Locale.ENGLISH)); } | @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); @Produces ResourceBundle getBundle(Locale locale); @Produces Locale getLocale(); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); @Produces ResourceBundle getBundle(Locale locale); @Produces Locale getLocale(); } |
@Test public void parseLocaleWithLanguage() { when(servletContext.getInitParameter(Config.FMT_LOCALE)).thenReturn("pt"); assertThat(localization.getLocale().getLanguage(), equalTo("pt")); } | @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); @Produces ResourceBundle getBundle(Locale locale); @Produces Locale getLocale(); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); @Produces ResourceBundle getBundle(Locale locale); @Produces Locale getLocale(); } |
@Test public void parseLocaleWithLanguageAndCountry() { when(servletContext.getInitParameter(Config.FMT_LOCALE)).thenReturn("pt_BR"); assertThat(localization.getLocale().getLanguage(), equalTo("pt")); assertThat(localization.getLocale().getCountry(), equalTo("BR")); } | @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); @Produces ResourceBundle getBundle(Locale locale); @Produces Locale getLocale(); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); @Produces ResourceBundle getBundle(Locale locale); @Produces Locale getLocale(); } |
@Test public void parseLocaleWithLanguageAndCountryAndVariant() { when(servletContext.getInitParameter(Config.FMT_LOCALE)).thenReturn("pt_BR_POSIX"); assertThat(localization.getLocale().getLanguage(), equalTo("pt")); assertThat(localization.getLocale().getCountry(), equalTo("BR")); assertThat(localization.getLocale().getVariant(), equalTo("POSIX")); } | @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); @Produces ResourceBundle getBundle(Locale locale); @Produces Locale getLocale(); } | JstlLocalization { @Produces public Locale getLocale() { Locale localeFromConfig = localeFor(Config.FMT_LOCALE); return firstNonNull(localeFromConfig, Locale.getDefault()); } protected JstlLocalization(); @Inject JstlLocalization(HttpServletRequest request); @Produces ResourceBundle getBundle(Locale locale); @Produces Locale getLocale(); } |
@Test public void firesStartEventOnStart() throws Exception { stack.start(); verify(interceptorsReadyEvent).fire(any(InterceptorsReady.class)); } | @Override public void start() { ControllerMethod method = controllerMethod.get(); interceptorsReadyEvent.fire(new InterceptorsReady(method)); LinkedList<InterceptorHandler> handlers = cache.getInterceptorHandlers(); internalStack.addFirst(handlers.iterator()); this.next(method, controllerInstance.get().getController()); internalStack.poll(); } | DefaultInterceptorStack implements InterceptorStack { @Override public void start() { ControllerMethod method = controllerMethod.get(); interceptorsReadyEvent.fire(new InterceptorsReady(method)); LinkedList<InterceptorHandler> handlers = cache.getInterceptorHandlers(); internalStack.addFirst(handlers.iterator()); this.next(method, controllerInstance.get().getController()); internalStack.poll(); } } | DefaultInterceptorStack implements InterceptorStack { @Override public void start() { ControllerMethod method = controllerMethod.get(); interceptorsReadyEvent.fire(new InterceptorsReady(method)); LinkedList<InterceptorHandler> handlers = cache.getInterceptorHandlers(); internalStack.addFirst(handlers.iterator()); this.next(method, controllerInstance.get().getController()); internalStack.poll(); } protected DefaultInterceptorStack(); @Inject DefaultInterceptorStack(InterceptorStackHandlersCache cache, Instance<ControllerMethod>
controllerMethod, Instance<ControllerInstance> controllerInstance, Event<InterceptorsExecuted> event,
Event<InterceptorsReady> stackStartingEvent); } | DefaultInterceptorStack implements InterceptorStack { @Override public void start() { ControllerMethod method = controllerMethod.get(); interceptorsReadyEvent.fire(new InterceptorsReady(method)); LinkedList<InterceptorHandler> handlers = cache.getInterceptorHandlers(); internalStack.addFirst(handlers.iterator()); this.next(method, controllerInstance.get().getController()); internalStack.poll(); } protected DefaultInterceptorStack(); @Inject DefaultInterceptorStack(InterceptorStackHandlersCache cache, Instance<ControllerMethod>
controllerMethod, Instance<ControllerInstance> controllerInstance, Event<InterceptorsExecuted> event,
Event<InterceptorsReady> stackStartingEvent); @Override void next(ControllerMethod method, Object controllerInstance); @Override void start(); } | DefaultInterceptorStack implements InterceptorStack { @Override public void start() { ControllerMethod method = controllerMethod.get(); interceptorsReadyEvent.fire(new InterceptorsReady(method)); LinkedList<InterceptorHandler> handlers = cache.getInterceptorHandlers(); internalStack.addFirst(handlers.iterator()); this.next(method, controllerInstance.get().getController()); internalStack.poll(); } protected DefaultInterceptorStack(); @Inject DefaultInterceptorStack(InterceptorStackHandlersCache cache, Instance<ControllerMethod>
controllerMethod, Instance<ControllerInstance> controllerInstance, Event<InterceptorsExecuted> event,
Event<InterceptorsReady> stackStartingEvent); @Override void next(ControllerMethod method, Object controllerInstance); @Override void start(); } |
@Test public void executesTheFirstHandler() throws Exception { stack.start(); verify(handler).execute(stack, controllerMethod, controller); } | @Override public void start() { ControllerMethod method = controllerMethod.get(); interceptorsReadyEvent.fire(new InterceptorsReady(method)); LinkedList<InterceptorHandler> handlers = cache.getInterceptorHandlers(); internalStack.addFirst(handlers.iterator()); this.next(method, controllerInstance.get().getController()); internalStack.poll(); } | DefaultInterceptorStack implements InterceptorStack { @Override public void start() { ControllerMethod method = controllerMethod.get(); interceptorsReadyEvent.fire(new InterceptorsReady(method)); LinkedList<InterceptorHandler> handlers = cache.getInterceptorHandlers(); internalStack.addFirst(handlers.iterator()); this.next(method, controllerInstance.get().getController()); internalStack.poll(); } } | DefaultInterceptorStack implements InterceptorStack { @Override public void start() { ControllerMethod method = controllerMethod.get(); interceptorsReadyEvent.fire(new InterceptorsReady(method)); LinkedList<InterceptorHandler> handlers = cache.getInterceptorHandlers(); internalStack.addFirst(handlers.iterator()); this.next(method, controllerInstance.get().getController()); internalStack.poll(); } protected DefaultInterceptorStack(); @Inject DefaultInterceptorStack(InterceptorStackHandlersCache cache, Instance<ControllerMethod>
controllerMethod, Instance<ControllerInstance> controllerInstance, Event<InterceptorsExecuted> event,
Event<InterceptorsReady> stackStartingEvent); } | DefaultInterceptorStack implements InterceptorStack { @Override public void start() { ControllerMethod method = controllerMethod.get(); interceptorsReadyEvent.fire(new InterceptorsReady(method)); LinkedList<InterceptorHandler> handlers = cache.getInterceptorHandlers(); internalStack.addFirst(handlers.iterator()); this.next(method, controllerInstance.get().getController()); internalStack.poll(); } protected DefaultInterceptorStack(); @Inject DefaultInterceptorStack(InterceptorStackHandlersCache cache, Instance<ControllerMethod>
controllerMethod, Instance<ControllerInstance> controllerInstance, Event<InterceptorsExecuted> event,
Event<InterceptorsReady> stackStartingEvent); @Override void next(ControllerMethod method, Object controllerInstance); @Override void start(); } | DefaultInterceptorStack implements InterceptorStack { @Override public void start() { ControllerMethod method = controllerMethod.get(); interceptorsReadyEvent.fire(new InterceptorsReady(method)); LinkedList<InterceptorHandler> handlers = cache.getInterceptorHandlers(); internalStack.addFirst(handlers.iterator()); this.next(method, controllerInstance.get().getController()); internalStack.poll(); } protected DefaultInterceptorStack(); @Inject DefaultInterceptorStack(InterceptorStackHandlersCache cache, Instance<ControllerMethod>
controllerMethod, Instance<ControllerInstance> controllerInstance, Event<InterceptorsExecuted> event,
Event<InterceptorsReady> stackStartingEvent); @Override void next(ControllerMethod method, Object controllerInstance); @Override void start(); } |
@Test public void addsASlashWhenUserForgotIt() throws SecurityException, NoSuchMethodException { List<Route> routes = parser.rulesFor(new DefaultBeanClass(ClientsController.class)); Route route = getRouteMatching(routes, "/noSlash"); assertThat(route, canHandle(ClientsController.class, "noSlash")); } | @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); } |
@Test public void doesntFireEndOfStackIfTheInterceptorsDontContinueTheStack() throws Exception { stack.start(); verify(interceptorsExecutedEvent, never()).fire(any(InterceptorsExecuted.class)); } | @Override public void start() { ControllerMethod method = controllerMethod.get(); interceptorsReadyEvent.fire(new InterceptorsReady(method)); LinkedList<InterceptorHandler> handlers = cache.getInterceptorHandlers(); internalStack.addFirst(handlers.iterator()); this.next(method, controllerInstance.get().getController()); internalStack.poll(); } | DefaultInterceptorStack implements InterceptorStack { @Override public void start() { ControllerMethod method = controllerMethod.get(); interceptorsReadyEvent.fire(new InterceptorsReady(method)); LinkedList<InterceptorHandler> handlers = cache.getInterceptorHandlers(); internalStack.addFirst(handlers.iterator()); this.next(method, controllerInstance.get().getController()); internalStack.poll(); } } | DefaultInterceptorStack implements InterceptorStack { @Override public void start() { ControllerMethod method = controllerMethod.get(); interceptorsReadyEvent.fire(new InterceptorsReady(method)); LinkedList<InterceptorHandler> handlers = cache.getInterceptorHandlers(); internalStack.addFirst(handlers.iterator()); this.next(method, controllerInstance.get().getController()); internalStack.poll(); } protected DefaultInterceptorStack(); @Inject DefaultInterceptorStack(InterceptorStackHandlersCache cache, Instance<ControllerMethod>
controllerMethod, Instance<ControllerInstance> controllerInstance, Event<InterceptorsExecuted> event,
Event<InterceptorsReady> stackStartingEvent); } | DefaultInterceptorStack implements InterceptorStack { @Override public void start() { ControllerMethod method = controllerMethod.get(); interceptorsReadyEvent.fire(new InterceptorsReady(method)); LinkedList<InterceptorHandler> handlers = cache.getInterceptorHandlers(); internalStack.addFirst(handlers.iterator()); this.next(method, controllerInstance.get().getController()); internalStack.poll(); } protected DefaultInterceptorStack(); @Inject DefaultInterceptorStack(InterceptorStackHandlersCache cache, Instance<ControllerMethod>
controllerMethod, Instance<ControllerInstance> controllerInstance, Event<InterceptorsExecuted> event,
Event<InterceptorsReady> stackStartingEvent); @Override void next(ControllerMethod method, Object controllerInstance); @Override void start(); } | DefaultInterceptorStack implements InterceptorStack { @Override public void start() { ControllerMethod method = controllerMethod.get(); interceptorsReadyEvent.fire(new InterceptorsReady(method)); LinkedList<InterceptorHandler> handlers = cache.getInterceptorHandlers(); internalStack.addFirst(handlers.iterator()); this.next(method, controllerInstance.get().getController()); internalStack.poll(); } protected DefaultInterceptorStack(); @Inject DefaultInterceptorStack(InterceptorStackHandlersCache cache, Instance<ControllerMethod>
controllerMethod, Instance<ControllerInstance> controllerInstance, Event<InterceptorsExecuted> event,
Event<InterceptorsReady> stackStartingEvent); @Override void next(ControllerMethod method, Object controllerInstance); @Override void start(); } |
@Test public void firesEndOfStackIfAllInterceptorsWereExecuted() throws Exception { doAnswer(callNext()).when(handler).execute(stack, controllerMethod, controller); stack.start(); verify(interceptorsExecutedEvent).fire(any(InterceptorsExecuted.class)); } | @Override public void start() { ControllerMethod method = controllerMethod.get(); interceptorsReadyEvent.fire(new InterceptorsReady(method)); LinkedList<InterceptorHandler> handlers = cache.getInterceptorHandlers(); internalStack.addFirst(handlers.iterator()); this.next(method, controllerInstance.get().getController()); internalStack.poll(); } | DefaultInterceptorStack implements InterceptorStack { @Override public void start() { ControllerMethod method = controllerMethod.get(); interceptorsReadyEvent.fire(new InterceptorsReady(method)); LinkedList<InterceptorHandler> handlers = cache.getInterceptorHandlers(); internalStack.addFirst(handlers.iterator()); this.next(method, controllerInstance.get().getController()); internalStack.poll(); } } | DefaultInterceptorStack implements InterceptorStack { @Override public void start() { ControllerMethod method = controllerMethod.get(); interceptorsReadyEvent.fire(new InterceptorsReady(method)); LinkedList<InterceptorHandler> handlers = cache.getInterceptorHandlers(); internalStack.addFirst(handlers.iterator()); this.next(method, controllerInstance.get().getController()); internalStack.poll(); } protected DefaultInterceptorStack(); @Inject DefaultInterceptorStack(InterceptorStackHandlersCache cache, Instance<ControllerMethod>
controllerMethod, Instance<ControllerInstance> controllerInstance, Event<InterceptorsExecuted> event,
Event<InterceptorsReady> stackStartingEvent); } | DefaultInterceptorStack implements InterceptorStack { @Override public void start() { ControllerMethod method = controllerMethod.get(); interceptorsReadyEvent.fire(new InterceptorsReady(method)); LinkedList<InterceptorHandler> handlers = cache.getInterceptorHandlers(); internalStack.addFirst(handlers.iterator()); this.next(method, controllerInstance.get().getController()); internalStack.poll(); } protected DefaultInterceptorStack(); @Inject DefaultInterceptorStack(InterceptorStackHandlersCache cache, Instance<ControllerMethod>
controllerMethod, Instance<ControllerInstance> controllerInstance, Event<InterceptorsExecuted> event,
Event<InterceptorsReady> stackStartingEvent); @Override void next(ControllerMethod method, Object controllerInstance); @Override void start(); } | DefaultInterceptorStack implements InterceptorStack { @Override public void start() { ControllerMethod method = controllerMethod.get(); interceptorsReadyEvent.fire(new InterceptorsReady(method)); LinkedList<InterceptorHandler> handlers = cache.getInterceptorHandlers(); internalStack.addFirst(handlers.iterator()); this.next(method, controllerInstance.get().getController()); internalStack.poll(); } protected DefaultInterceptorStack(); @Inject DefaultInterceptorStack(InterceptorStackHandlersCache cache, Instance<ControllerMethod>
controllerMethod, Instance<ControllerInstance> controllerInstance, Event<InterceptorsExecuted> event,
Event<InterceptorsReady> stackStartingEvent); @Override void next(ControllerMethod method, Object controllerInstance); @Override void start(); } |
@Test public void withRootException() { mapper.record(Exception.class).forwardTo(DEFAULT_REDIRECT); mapper.findByException(new Exception()).replay(result); verify(result).forwardTo(DEFAULT_REDIRECT); } | public void replay(Result result) { Object current = result; for (ExceptionRecorderParameter p : parameters) { current = reflectionProvider.invoke(current, p.getMethod(), p.getArgs()); } } | ExceptionRecorder implements MethodInvocation<T> { public void replay(Result result) { Object current = result; for (ExceptionRecorderParameter p : parameters) { current = reflectionProvider.invoke(current, p.getMethod(), p.getArgs()); } } } | ExceptionRecorder implements MethodInvocation<T> { public void replay(Result result) { Object current = result; for (ExceptionRecorderParameter p : parameters) { current = reflectionProvider.invoke(current, p.getMethod(), p.getArgs()); } } ExceptionRecorder(Proxifier proxifier, ReflectionProvider reflectionProvider); } | ExceptionRecorder implements MethodInvocation<T> { public void replay(Result result) { Object current = result; for (ExceptionRecorderParameter p : parameters) { current = reflectionProvider.invoke(current, p.getMethod(), p.getArgs()); } } ExceptionRecorder(Proxifier proxifier, ReflectionProvider reflectionProvider); @Override @SuppressWarnings({ "unchecked", "rawtypes" }) Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod); void replay(Result result); } | ExceptionRecorder implements MethodInvocation<T> { public void replay(Result result) { Object current = result; for (ExceptionRecorderParameter p : parameters) { current = reflectionProvider.invoke(current, p.getMethod(), p.getArgs()); } } ExceptionRecorder(Proxifier proxifier, ReflectionProvider reflectionProvider); @Override @SuppressWarnings({ "unchecked", "rawtypes" }) Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod); void replay(Result result); } |
@Test public void withNestedException() { mapper.record(IllegalStateException.class).forwardTo(DEFAULT_REDIRECT); mapper.findByException(new RuntimeException(new IllegalStateException())).replay(result); verify(result).forwardTo(DEFAULT_REDIRECT); } | public void replay(Result result) { Object current = result; for (ExceptionRecorderParameter p : parameters) { current = reflectionProvider.invoke(current, p.getMethod(), p.getArgs()); } } | ExceptionRecorder implements MethodInvocation<T> { public void replay(Result result) { Object current = result; for (ExceptionRecorderParameter p : parameters) { current = reflectionProvider.invoke(current, p.getMethod(), p.getArgs()); } } } | ExceptionRecorder implements MethodInvocation<T> { public void replay(Result result) { Object current = result; for (ExceptionRecorderParameter p : parameters) { current = reflectionProvider.invoke(current, p.getMethod(), p.getArgs()); } } ExceptionRecorder(Proxifier proxifier, ReflectionProvider reflectionProvider); } | ExceptionRecorder implements MethodInvocation<T> { public void replay(Result result) { Object current = result; for (ExceptionRecorderParameter p : parameters) { current = reflectionProvider.invoke(current, p.getMethod(), p.getArgs()); } } ExceptionRecorder(Proxifier proxifier, ReflectionProvider reflectionProvider); @Override @SuppressWarnings({ "unchecked", "rawtypes" }) Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod); void replay(Result result); } | ExceptionRecorder implements MethodInvocation<T> { public void replay(Result result) { Object current = result; for (ExceptionRecorderParameter p : parameters) { current = reflectionProvider.invoke(current, p.getMethod(), p.getArgs()); } } ExceptionRecorder(Proxifier proxifier, ReflectionProvider reflectionProvider); @Override @SuppressWarnings({ "unchecked", "rawtypes" }) Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod); void replay(Result result); } |
@Test public void shouldComplainWhenUnableToInstantiateAnInterceptor() throws InterceptionException, IOException { exception.expect(InterceptionException.class); exception.expectMessage(containsString("Unable to instantiate interceptor for")); when(container.instanceFor(MyWeirdInterceptor.class)).thenReturn(null); ToInstantiateInterceptorHandler handler = new ToInstantiateInterceptorHandler(container, MyWeirdInterceptor.class, new ExecuteMethodExceptionHandler()); handler.execute(null, null, null); } | @Override public void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance) throws InterceptionException { final Interceptor interceptor = (Interceptor) container.instanceFor(type); if (interceptor == null) { throw new InterceptionException("Unable to instantiate interceptor for " + type.getName() + ": the container returned null."); } if (interceptor.accepts(method)) { logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); executeSafely(stack, method, controllerInstance, interceptor); } else { stack.next(method, controllerInstance); } } | ToInstantiateInterceptorHandler implements InterceptorHandler { @Override public void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance) throws InterceptionException { final Interceptor interceptor = (Interceptor) container.instanceFor(type); if (interceptor == null) { throw new InterceptionException("Unable to instantiate interceptor for " + type.getName() + ": the container returned null."); } if (interceptor.accepts(method)) { logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); executeSafely(stack, method, controllerInstance, interceptor); } else { stack.next(method, controllerInstance); } } } | ToInstantiateInterceptorHandler implements InterceptorHandler { @Override public void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance) throws InterceptionException { final Interceptor interceptor = (Interceptor) container.instanceFor(type); if (interceptor == null) { throw new InterceptionException("Unable to instantiate interceptor for " + type.getName() + ": the container returned null."); } if (interceptor.accepts(method)) { logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); executeSafely(stack, method, controllerInstance, interceptor); } else { stack.next(method, controllerInstance); } } ToInstantiateInterceptorHandler(Container container, Class<?> type, ExecuteMethodExceptionHandler executeMethodExceptionHandler); } | ToInstantiateInterceptorHandler implements InterceptorHandler { @Override public void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance) throws InterceptionException { final Interceptor interceptor = (Interceptor) container.instanceFor(type); if (interceptor == null) { throw new InterceptionException("Unable to instantiate interceptor for " + type.getName() + ": the container returned null."); } if (interceptor.accepts(method)) { logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); executeSafely(stack, method, controllerInstance, interceptor); } else { stack.next(method, controllerInstance); } } ToInstantiateInterceptorHandler(Container container, Class<?> type, ExecuteMethodExceptionHandler executeMethodExceptionHandler); @Override void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance); @Override String toString(); } | ToInstantiateInterceptorHandler implements InterceptorHandler { @Override public void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance) throws InterceptionException { final Interceptor interceptor = (Interceptor) container.instanceFor(type); if (interceptor == null) { throw new InterceptionException("Unable to instantiate interceptor for " + type.getName() + ": the container returned null."); } if (interceptor.accepts(method)) { logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); executeSafely(stack, method, controllerInstance, interceptor); } else { stack.next(method, controllerInstance); } } ToInstantiateInterceptorHandler(Container container, Class<?> type, ExecuteMethodExceptionHandler executeMethodExceptionHandler); @Override void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance); @Override String toString(); } |
@Test public void shouldInvokeInterceptorsMethodIfAbleToInstantiateIt() throws InterceptionException, IOException { final Object instance = new Object(); when(container.instanceFor(Interceptor.class)).thenReturn(interceptor); when(interceptor.accepts(method)).thenReturn(true); ToInstantiateInterceptorHandler handler = new ToInstantiateInterceptorHandler(container, Interceptor.class, new ExecuteMethodExceptionHandler()); handler.execute(stack, method, instance); verify(interceptor).intercept(stack, method, instance); } | @Override public void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance) throws InterceptionException { final Interceptor interceptor = (Interceptor) container.instanceFor(type); if (interceptor == null) { throw new InterceptionException("Unable to instantiate interceptor for " + type.getName() + ": the container returned null."); } if (interceptor.accepts(method)) { logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); executeSafely(stack, method, controllerInstance, interceptor); } else { stack.next(method, controllerInstance); } } | ToInstantiateInterceptorHandler implements InterceptorHandler { @Override public void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance) throws InterceptionException { final Interceptor interceptor = (Interceptor) container.instanceFor(type); if (interceptor == null) { throw new InterceptionException("Unable to instantiate interceptor for " + type.getName() + ": the container returned null."); } if (interceptor.accepts(method)) { logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); executeSafely(stack, method, controllerInstance, interceptor); } else { stack.next(method, controllerInstance); } } } | ToInstantiateInterceptorHandler implements InterceptorHandler { @Override public void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance) throws InterceptionException { final Interceptor interceptor = (Interceptor) container.instanceFor(type); if (interceptor == null) { throw new InterceptionException("Unable to instantiate interceptor for " + type.getName() + ": the container returned null."); } if (interceptor.accepts(method)) { logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); executeSafely(stack, method, controllerInstance, interceptor); } else { stack.next(method, controllerInstance); } } ToInstantiateInterceptorHandler(Container container, Class<?> type, ExecuteMethodExceptionHandler executeMethodExceptionHandler); } | ToInstantiateInterceptorHandler implements InterceptorHandler { @Override public void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance) throws InterceptionException { final Interceptor interceptor = (Interceptor) container.instanceFor(type); if (interceptor == null) { throw new InterceptionException("Unable to instantiate interceptor for " + type.getName() + ": the container returned null."); } if (interceptor.accepts(method)) { logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); executeSafely(stack, method, controllerInstance, interceptor); } else { stack.next(method, controllerInstance); } } ToInstantiateInterceptorHandler(Container container, Class<?> type, ExecuteMethodExceptionHandler executeMethodExceptionHandler); @Override void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance); @Override String toString(); } | ToInstantiateInterceptorHandler implements InterceptorHandler { @Override public void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance) throws InterceptionException { final Interceptor interceptor = (Interceptor) container.instanceFor(type); if (interceptor == null) { throw new InterceptionException("Unable to instantiate interceptor for " + type.getName() + ": the container returned null."); } if (interceptor.accepts(method)) { logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); executeSafely(stack, method, controllerInstance, interceptor); } else { stack.next(method, controllerInstance); } } ToInstantiateInterceptorHandler(Container container, Class<?> type, ExecuteMethodExceptionHandler executeMethodExceptionHandler); @Override void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance); @Override String toString(); } |
@Test public void shouldNotInvokeInterceptorsMethodIfInterceptorDoesntAcceptsResource() throws InterceptionException, IOException { final Object instance = new Object(); when(container.instanceFor(Interceptor.class)).thenReturn(interceptor); when(interceptor.accepts(method)).thenReturn(false); ToInstantiateInterceptorHandler handler = new ToInstantiateInterceptorHandler(container, Interceptor.class, new ExecuteMethodExceptionHandler()); handler.execute(stack, method, instance); verify(interceptor, never()).intercept(stack, method, instance); verify(stack).next(method, instance); } | @Override public void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance) throws InterceptionException { final Interceptor interceptor = (Interceptor) container.instanceFor(type); if (interceptor == null) { throw new InterceptionException("Unable to instantiate interceptor for " + type.getName() + ": the container returned null."); } if (interceptor.accepts(method)) { logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); executeSafely(stack, method, controllerInstance, interceptor); } else { stack.next(method, controllerInstance); } } | ToInstantiateInterceptorHandler implements InterceptorHandler { @Override public void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance) throws InterceptionException { final Interceptor interceptor = (Interceptor) container.instanceFor(type); if (interceptor == null) { throw new InterceptionException("Unable to instantiate interceptor for " + type.getName() + ": the container returned null."); } if (interceptor.accepts(method)) { logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); executeSafely(stack, method, controllerInstance, interceptor); } else { stack.next(method, controllerInstance); } } } | ToInstantiateInterceptorHandler implements InterceptorHandler { @Override public void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance) throws InterceptionException { final Interceptor interceptor = (Interceptor) container.instanceFor(type); if (interceptor == null) { throw new InterceptionException("Unable to instantiate interceptor for " + type.getName() + ": the container returned null."); } if (interceptor.accepts(method)) { logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); executeSafely(stack, method, controllerInstance, interceptor); } else { stack.next(method, controllerInstance); } } ToInstantiateInterceptorHandler(Container container, Class<?> type, ExecuteMethodExceptionHandler executeMethodExceptionHandler); } | ToInstantiateInterceptorHandler implements InterceptorHandler { @Override public void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance) throws InterceptionException { final Interceptor interceptor = (Interceptor) container.instanceFor(type); if (interceptor == null) { throw new InterceptionException("Unable to instantiate interceptor for " + type.getName() + ": the container returned null."); } if (interceptor.accepts(method)) { logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); executeSafely(stack, method, controllerInstance, interceptor); } else { stack.next(method, controllerInstance); } } ToInstantiateInterceptorHandler(Container container, Class<?> type, ExecuteMethodExceptionHandler executeMethodExceptionHandler); @Override void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance); @Override String toString(); } | ToInstantiateInterceptorHandler implements InterceptorHandler { @Override public void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance) throws InterceptionException { final Interceptor interceptor = (Interceptor) container.instanceFor(type); if (interceptor == null) { throw new InterceptionException("Unable to instantiate interceptor for " + type.getName() + ": the container returned null."); } if (interceptor.accepts(method)) { logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); executeSafely(stack, method, controllerInstance, interceptor); } else { stack.next(method, controllerInstance); } } ToInstantiateInterceptorHandler(Container container, Class<?> type, ExecuteMethodExceptionHandler executeMethodExceptionHandler); @Override void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance); @Override String toString(); } |
@Test public void shouldCatchValidationExceptionOfValidatedInterceptor() { MyValidatedInterceptor validatedInterceptor = new MyValidatedInterceptor(); when(container.instanceFor(MyValidatedInterceptor.class)).thenReturn(validatedInterceptor); ExecuteMethodExceptionHandler exceptionHandler = Mockito.spy(new ExecuteMethodExceptionHandler()); ToInstantiateInterceptorHandler handler = new ToInstantiateInterceptorHandler(container, MyValidatedInterceptor.class, exceptionHandler); handler.execute(stack, method, new Object()); verify(exceptionHandler).handle(Mockito.any(ValidationException.class)); } | @Override public void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance) throws InterceptionException { final Interceptor interceptor = (Interceptor) container.instanceFor(type); if (interceptor == null) { throw new InterceptionException("Unable to instantiate interceptor for " + type.getName() + ": the container returned null."); } if (interceptor.accepts(method)) { logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); executeSafely(stack, method, controllerInstance, interceptor); } else { stack.next(method, controllerInstance); } } | ToInstantiateInterceptorHandler implements InterceptorHandler { @Override public void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance) throws InterceptionException { final Interceptor interceptor = (Interceptor) container.instanceFor(type); if (interceptor == null) { throw new InterceptionException("Unable to instantiate interceptor for " + type.getName() + ": the container returned null."); } if (interceptor.accepts(method)) { logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); executeSafely(stack, method, controllerInstance, interceptor); } else { stack.next(method, controllerInstance); } } } | ToInstantiateInterceptorHandler implements InterceptorHandler { @Override public void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance) throws InterceptionException { final Interceptor interceptor = (Interceptor) container.instanceFor(type); if (interceptor == null) { throw new InterceptionException("Unable to instantiate interceptor for " + type.getName() + ": the container returned null."); } if (interceptor.accepts(method)) { logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); executeSafely(stack, method, controllerInstance, interceptor); } else { stack.next(method, controllerInstance); } } ToInstantiateInterceptorHandler(Container container, Class<?> type, ExecuteMethodExceptionHandler executeMethodExceptionHandler); } | ToInstantiateInterceptorHandler implements InterceptorHandler { @Override public void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance) throws InterceptionException { final Interceptor interceptor = (Interceptor) container.instanceFor(type); if (interceptor == null) { throw new InterceptionException("Unable to instantiate interceptor for " + type.getName() + ": the container returned null."); } if (interceptor.accepts(method)) { logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); executeSafely(stack, method, controllerInstance, interceptor); } else { stack.next(method, controllerInstance); } } ToInstantiateInterceptorHandler(Container container, Class<?> type, ExecuteMethodExceptionHandler executeMethodExceptionHandler); @Override void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance); @Override String toString(); } | ToInstantiateInterceptorHandler implements InterceptorHandler { @Override public void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance) throws InterceptionException { final Interceptor interceptor = (Interceptor) container.instanceFor(type); if (interceptor == null) { throw new InterceptionException("Unable to instantiate interceptor for " + type.getName() + ": the container returned null."); } if (interceptor.accepts(method)) { logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); executeSafely(stack, method, controllerInstance, interceptor); } else { stack.next(method, controllerInstance); } } ToInstantiateInterceptorHandler(Container container, Class<?> type, ExecuteMethodExceptionHandler executeMethodExceptionHandler); @Override void execute(final InterceptorStack stack, final ControllerMethod method, final Object controllerInstance); @Override String toString(); } |
@Test public void complainsIfNoConverterFound() { exception.expect(IllegalStateException.class); exception.expectMessage("Unable to find converter for " + getClass().getName()); converters.to(DefaultConvertersTest.class); } | @SuppressWarnings("unchecked") @Override public <T> Converter<T> to(Class<T> clazz) { Class<? extends Converter<?>> converterType = findConverterTypeFromCache(clazz); checkState(!converterType.equals(NullConverter.class), "Unable to find converter for %s", clazz.getName()); logger.debug("found converter {} to {}", converterType.getName(), clazz.getName()); return (Converter<T>) container.instanceFor(converterType); } | DefaultConverters implements Converters { @SuppressWarnings("unchecked") @Override public <T> Converter<T> to(Class<T> clazz) { Class<? extends Converter<?>> converterType = findConverterTypeFromCache(clazz); checkState(!converterType.equals(NullConverter.class), "Unable to find converter for %s", clazz.getName()); logger.debug("found converter {} to {}", converterType.getName(), clazz.getName()); return (Converter<T>) container.instanceFor(converterType); } } | DefaultConverters implements Converters { @SuppressWarnings("unchecked") @Override public <T> Converter<T> to(Class<T> clazz) { Class<? extends Converter<?>> converterType = findConverterTypeFromCache(clazz); checkState(!converterType.equals(NullConverter.class), "Unable to find converter for %s", clazz.getName()); logger.debug("found converter {} to {}", converterType.getName(), clazz.getName()); return (Converter<T>) container.instanceFor(converterType); } protected DefaultConverters(); @Inject DefaultConverters(Container container, @LRU CacheStore<Class<?>, Class<? extends Converter<?>>> cache); } | DefaultConverters implements Converters { @SuppressWarnings("unchecked") @Override public <T> Converter<T> to(Class<T> clazz) { Class<? extends Converter<?>> converterType = findConverterTypeFromCache(clazz); checkState(!converterType.equals(NullConverter.class), "Unable to find converter for %s", clazz.getName()); logger.debug("found converter {} to {}", converterType.getName(), clazz.getName()); return (Converter<T>) container.instanceFor(converterType); } protected DefaultConverters(); @Inject DefaultConverters(Container container, @LRU CacheStore<Class<?>, Class<? extends Converter<?>>> cache); @Override void register(Class<? extends Converter<?>> converterClass); @SuppressWarnings("unchecked") @Override Converter<T> to(Class<T> clazz); @Override boolean existsFor(Class<?> type); @Override boolean existsTwoWayFor(Class<?> type); @Override TwoWayConverter<?> twoWayConverterFor(Class<?> type); } | DefaultConverters implements Converters { @SuppressWarnings("unchecked") @Override public <T> Converter<T> to(Class<T> clazz) { Class<? extends Converter<?>> converterType = findConverterTypeFromCache(clazz); checkState(!converterType.equals(NullConverter.class), "Unable to find converter for %s", clazz.getName()); logger.debug("found converter {} to {}", converterType.getName(), clazz.getName()); return (Converter<T>) container.instanceFor(converterType); } protected DefaultConverters(); @Inject DefaultConverters(Container container, @LRU CacheStore<Class<?>, Class<? extends Converter<?>>> cache); @Override void register(Class<? extends Converter<?>> converterClass); @SuppressWarnings("unchecked") @Override Converter<T> to(Class<T> clazz); @Override boolean existsFor(Class<?> type); @Override boolean existsTwoWayFor(Class<?> type); @Override TwoWayConverter<?> twoWayConverterFor(Class<?> type); } |
@Test public void convertingANonAnnotatedConverterEndsUpComplaining() { exception.expect(IllegalStateException.class); exception.expectMessage("The converter type " + WrongConverter.class.getName() + " should have the Convert annotation"); converters.register(WrongConverter.class); } | @Override public void register(Class<? extends Converter<?>> converterClass) { Convert type = converterClass.getAnnotation(Convert.class); checkState(type != null, "The converter type %s should have the Convert annotation", converterClass.getName()); Class<? extends Converter<?>> currentConverter = findConverterType(type.value()); if (!currentConverter.equals(NullConverter.class)) { int priority = getConverterPriority(converterClass); int priorityCurrent = getConverterPriority(currentConverter); Convert currentType = currentConverter.getAnnotation(Convert.class); checkState(priority != priorityCurrent || !type.value().equals(currentType.value()), "Converter %s have same priority than %s", converterClass, currentConverter); if (priority > priorityCurrent) { logger.debug("Overriding converter {} with {} because have more priority", currentConverter, converterClass); classes.remove(currentConverter); classes.add(converterClass); } else { logger.debug("Converter {} not registered because have less priority than {}", converterClass, currentConverter); } } logger.debug("adding converter {} to {}", converterClass, type.value()); classes.add(converterClass); } | DefaultConverters implements Converters { @Override public void register(Class<? extends Converter<?>> converterClass) { Convert type = converterClass.getAnnotation(Convert.class); checkState(type != null, "The converter type %s should have the Convert annotation", converterClass.getName()); Class<? extends Converter<?>> currentConverter = findConverterType(type.value()); if (!currentConverter.equals(NullConverter.class)) { int priority = getConverterPriority(converterClass); int priorityCurrent = getConverterPriority(currentConverter); Convert currentType = currentConverter.getAnnotation(Convert.class); checkState(priority != priorityCurrent || !type.value().equals(currentType.value()), "Converter %s have same priority than %s", converterClass, currentConverter); if (priority > priorityCurrent) { logger.debug("Overriding converter {} with {} because have more priority", currentConverter, converterClass); classes.remove(currentConverter); classes.add(converterClass); } else { logger.debug("Converter {} not registered because have less priority than {}", converterClass, currentConverter); } } logger.debug("adding converter {} to {}", converterClass, type.value()); classes.add(converterClass); } } | DefaultConverters implements Converters { @Override public void register(Class<? extends Converter<?>> converterClass) { Convert type = converterClass.getAnnotation(Convert.class); checkState(type != null, "The converter type %s should have the Convert annotation", converterClass.getName()); Class<? extends Converter<?>> currentConverter = findConverterType(type.value()); if (!currentConverter.equals(NullConverter.class)) { int priority = getConverterPriority(converterClass); int priorityCurrent = getConverterPriority(currentConverter); Convert currentType = currentConverter.getAnnotation(Convert.class); checkState(priority != priorityCurrent || !type.value().equals(currentType.value()), "Converter %s have same priority than %s", converterClass, currentConverter); if (priority > priorityCurrent) { logger.debug("Overriding converter {} with {} because have more priority", currentConverter, converterClass); classes.remove(currentConverter); classes.add(converterClass); } else { logger.debug("Converter {} not registered because have less priority than {}", converterClass, currentConverter); } } logger.debug("adding converter {} to {}", converterClass, type.value()); classes.add(converterClass); } protected DefaultConverters(); @Inject DefaultConverters(Container container, @LRU CacheStore<Class<?>, Class<? extends Converter<?>>> cache); } | DefaultConverters implements Converters { @Override public void register(Class<? extends Converter<?>> converterClass) { Convert type = converterClass.getAnnotation(Convert.class); checkState(type != null, "The converter type %s should have the Convert annotation", converterClass.getName()); Class<? extends Converter<?>> currentConverter = findConverterType(type.value()); if (!currentConverter.equals(NullConverter.class)) { int priority = getConverterPriority(converterClass); int priorityCurrent = getConverterPriority(currentConverter); Convert currentType = currentConverter.getAnnotation(Convert.class); checkState(priority != priorityCurrent || !type.value().equals(currentType.value()), "Converter %s have same priority than %s", converterClass, currentConverter); if (priority > priorityCurrent) { logger.debug("Overriding converter {} with {} because have more priority", currentConverter, converterClass); classes.remove(currentConverter); classes.add(converterClass); } else { logger.debug("Converter {} not registered because have less priority than {}", converterClass, currentConverter); } } logger.debug("adding converter {} to {}", converterClass, type.value()); classes.add(converterClass); } protected DefaultConverters(); @Inject DefaultConverters(Container container, @LRU CacheStore<Class<?>, Class<? extends Converter<?>>> cache); @Override void register(Class<? extends Converter<?>> converterClass); @SuppressWarnings("unchecked") @Override Converter<T> to(Class<T> clazz); @Override boolean existsFor(Class<?> type); @Override boolean existsTwoWayFor(Class<?> type); @Override TwoWayConverter<?> twoWayConverterFor(Class<?> type); } | DefaultConverters implements Converters { @Override public void register(Class<? extends Converter<?>> converterClass) { Convert type = converterClass.getAnnotation(Convert.class); checkState(type != null, "The converter type %s should have the Convert annotation", converterClass.getName()); Class<? extends Converter<?>> currentConverter = findConverterType(type.value()); if (!currentConverter.equals(NullConverter.class)) { int priority = getConverterPriority(converterClass); int priorityCurrent = getConverterPriority(currentConverter); Convert currentType = currentConverter.getAnnotation(Convert.class); checkState(priority != priorityCurrent || !type.value().equals(currentType.value()), "Converter %s have same priority than %s", converterClass, currentConverter); if (priority > priorityCurrent) { logger.debug("Overriding converter {} with {} because have more priority", currentConverter, converterClass); classes.remove(currentConverter); classes.add(converterClass); } else { logger.debug("Converter {} not registered because have less priority than {}", converterClass, currentConverter); } } logger.debug("adding converter {} to {}", converterClass, type.value()); classes.add(converterClass); } protected DefaultConverters(); @Inject DefaultConverters(Container container, @LRU CacheStore<Class<?>, Class<? extends Converter<?>>> cache); @Override void register(Class<? extends Converter<?>> converterClass); @SuppressWarnings("unchecked") @Override Converter<T> to(Class<T> clazz); @Override boolean existsFor(Class<?> type); @Override boolean existsTwoWayFor(Class<?> type); @Override TwoWayConverter<?> twoWayConverterFor(Class<?> type); } |
@Test public void matchesWhenUsingAWildcard() throws SecurityException, NoSuchMethodException { List<Route> routes = parser.rulesFor(new DefaultBeanClass(ClientsController.class)); Route route = getRouteMatching(routes, "/move/second/child"); assertThat(route, canHandle(ClientsController.class, "move")); } | @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); } |
@Test public void shouldForbidConverterWithSamePriority() { exception.expect(IllegalStateException.class); exception.expectMessage(String.format("Converter %s have same priority than %s", MyThirdConverter.class, MySecondConverter.class)); converters.register(MySecondConverter.class); converters.register(MyThirdConverter.class); } | @Override public void register(Class<? extends Converter<?>> converterClass) { Convert type = converterClass.getAnnotation(Convert.class); checkState(type != null, "The converter type %s should have the Convert annotation", converterClass.getName()); Class<? extends Converter<?>> currentConverter = findConverterType(type.value()); if (!currentConverter.equals(NullConverter.class)) { int priority = getConverterPriority(converterClass); int priorityCurrent = getConverterPriority(currentConverter); Convert currentType = currentConverter.getAnnotation(Convert.class); checkState(priority != priorityCurrent || !type.value().equals(currentType.value()), "Converter %s have same priority than %s", converterClass, currentConverter); if (priority > priorityCurrent) { logger.debug("Overriding converter {} with {} because have more priority", currentConverter, converterClass); classes.remove(currentConverter); classes.add(converterClass); } else { logger.debug("Converter {} not registered because have less priority than {}", converterClass, currentConverter); } } logger.debug("adding converter {} to {}", converterClass, type.value()); classes.add(converterClass); } | DefaultConverters implements Converters { @Override public void register(Class<? extends Converter<?>> converterClass) { Convert type = converterClass.getAnnotation(Convert.class); checkState(type != null, "The converter type %s should have the Convert annotation", converterClass.getName()); Class<? extends Converter<?>> currentConverter = findConverterType(type.value()); if (!currentConverter.equals(NullConverter.class)) { int priority = getConverterPriority(converterClass); int priorityCurrent = getConverterPriority(currentConverter); Convert currentType = currentConverter.getAnnotation(Convert.class); checkState(priority != priorityCurrent || !type.value().equals(currentType.value()), "Converter %s have same priority than %s", converterClass, currentConverter); if (priority > priorityCurrent) { logger.debug("Overriding converter {} with {} because have more priority", currentConverter, converterClass); classes.remove(currentConverter); classes.add(converterClass); } else { logger.debug("Converter {} not registered because have less priority than {}", converterClass, currentConverter); } } logger.debug("adding converter {} to {}", converterClass, type.value()); classes.add(converterClass); } } | DefaultConverters implements Converters { @Override public void register(Class<? extends Converter<?>> converterClass) { Convert type = converterClass.getAnnotation(Convert.class); checkState(type != null, "The converter type %s should have the Convert annotation", converterClass.getName()); Class<? extends Converter<?>> currentConverter = findConverterType(type.value()); if (!currentConverter.equals(NullConverter.class)) { int priority = getConverterPriority(converterClass); int priorityCurrent = getConverterPriority(currentConverter); Convert currentType = currentConverter.getAnnotation(Convert.class); checkState(priority != priorityCurrent || !type.value().equals(currentType.value()), "Converter %s have same priority than %s", converterClass, currentConverter); if (priority > priorityCurrent) { logger.debug("Overriding converter {} with {} because have more priority", currentConverter, converterClass); classes.remove(currentConverter); classes.add(converterClass); } else { logger.debug("Converter {} not registered because have less priority than {}", converterClass, currentConverter); } } logger.debug("adding converter {} to {}", converterClass, type.value()); classes.add(converterClass); } protected DefaultConverters(); @Inject DefaultConverters(Container container, @LRU CacheStore<Class<?>, Class<? extends Converter<?>>> cache); } | DefaultConverters implements Converters { @Override public void register(Class<? extends Converter<?>> converterClass) { Convert type = converterClass.getAnnotation(Convert.class); checkState(type != null, "The converter type %s should have the Convert annotation", converterClass.getName()); Class<? extends Converter<?>> currentConverter = findConverterType(type.value()); if (!currentConverter.equals(NullConverter.class)) { int priority = getConverterPriority(converterClass); int priorityCurrent = getConverterPriority(currentConverter); Convert currentType = currentConverter.getAnnotation(Convert.class); checkState(priority != priorityCurrent || !type.value().equals(currentType.value()), "Converter %s have same priority than %s", converterClass, currentConverter); if (priority > priorityCurrent) { logger.debug("Overriding converter {} with {} because have more priority", currentConverter, converterClass); classes.remove(currentConverter); classes.add(converterClass); } else { logger.debug("Converter {} not registered because have less priority than {}", converterClass, currentConverter); } } logger.debug("adding converter {} to {}", converterClass, type.value()); classes.add(converterClass); } protected DefaultConverters(); @Inject DefaultConverters(Container container, @LRU CacheStore<Class<?>, Class<? extends Converter<?>>> cache); @Override void register(Class<? extends Converter<?>> converterClass); @SuppressWarnings("unchecked") @Override Converter<T> to(Class<T> clazz); @Override boolean existsFor(Class<?> type); @Override boolean existsTwoWayFor(Class<?> type); @Override TwoWayConverter<?> twoWayConverterFor(Class<?> type); } | DefaultConverters implements Converters { @Override public void register(Class<? extends Converter<?>> converterClass) { Convert type = converterClass.getAnnotation(Convert.class); checkState(type != null, "The converter type %s should have the Convert annotation", converterClass.getName()); Class<? extends Converter<?>> currentConverter = findConverterType(type.value()); if (!currentConverter.equals(NullConverter.class)) { int priority = getConverterPriority(converterClass); int priorityCurrent = getConverterPriority(currentConverter); Convert currentType = currentConverter.getAnnotation(Convert.class); checkState(priority != priorityCurrent || !type.value().equals(currentType.value()), "Converter %s have same priority than %s", converterClass, currentConverter); if (priority > priorityCurrent) { logger.debug("Overriding converter {} with {} because have more priority", currentConverter, converterClass); classes.remove(currentConverter); classes.add(converterClass); } else { logger.debug("Converter {} not registered because have less priority than {}", converterClass, currentConverter); } } logger.debug("adding converter {} to {}", converterClass, type.value()); classes.add(converterClass); } protected DefaultConverters(); @Inject DefaultConverters(Container container, @LRU CacheStore<Class<?>, Class<? extends Converter<?>>> cache); @Override void register(Class<? extends Converter<?>> converterClass); @SuppressWarnings("unchecked") @Override Converter<T> to(Class<T> clazz); @Override boolean existsFor(Class<?> type); @Override boolean existsTwoWayFor(Class<?> type); @Override TwoWayConverter<?> twoWayConverterFor(Class<?> type); } |
@Test public void returnsTrueForRealStaticResources() throws Exception { String key = file.getAbsolutePath(); when(request.getRequestURI()).thenReturn("/contextName/" +key); when(request.getContextPath()).thenReturn("/contextName/"); when(context.getResource(key)).thenReturn(file.toURI().toURL()); boolean result = new DefaultStaticContentHandler(context).requestingStaticFile(request); assertThat(result, is(equalTo(true))); } | @Override public boolean requestingStaticFile(HttpServletRequest request) throws MalformedURLException { URL resourceUrl = context.getResource(uriRelativeToContextRoot(request)); return resourceUrl != null && isAFile(resourceUrl); } | DefaultStaticContentHandler implements StaticContentHandler { @Override public boolean requestingStaticFile(HttpServletRequest request) throws MalformedURLException { URL resourceUrl = context.getResource(uriRelativeToContextRoot(request)); return resourceUrl != null && isAFile(resourceUrl); } } | DefaultStaticContentHandler implements StaticContentHandler { @Override public boolean requestingStaticFile(HttpServletRequest request) throws MalformedURLException { URL resourceUrl = context.getResource(uriRelativeToContextRoot(request)); return resourceUrl != null && isAFile(resourceUrl); } protected DefaultStaticContentHandler(); @Inject DefaultStaticContentHandler(ServletContext context); } | DefaultStaticContentHandler implements StaticContentHandler { @Override public boolean requestingStaticFile(HttpServletRequest request) throws MalformedURLException { URL resourceUrl = context.getResource(uriRelativeToContextRoot(request)); return resourceUrl != null && isAFile(resourceUrl); } protected DefaultStaticContentHandler(); @Inject DefaultStaticContentHandler(ServletContext context); @Override boolean requestingStaticFile(HttpServletRequest request); @Override void deferProcessingToContainer(FilterChain filterChain, HttpServletRequest request,
HttpServletResponse response); } | DefaultStaticContentHandler implements StaticContentHandler { @Override public boolean requestingStaticFile(HttpServletRequest request) throws MalformedURLException { URL resourceUrl = context.getResource(uriRelativeToContextRoot(request)); return resourceUrl != null && isAFile(resourceUrl); } protected DefaultStaticContentHandler(); @Inject DefaultStaticContentHandler(ServletContext context); @Override boolean requestingStaticFile(HttpServletRequest request); @Override void deferProcessingToContainer(FilterChain filterChain, HttpServletRequest request,
HttpServletResponse response); } |
@Test public void returnsTrueForRealStaticResourcesWithQueryString() throws Exception { String key = file.getAbsolutePath(); when(request.getRequestURI()).thenReturn("/contextName/" + key + "?jsesssionid=12lkjahfsd12414"); when(request.getContextPath()).thenReturn("/contextName/"); when(context.getResource(key)).thenReturn(file.toURI().toURL()); boolean result = new DefaultStaticContentHandler(context).requestingStaticFile(request); assertThat(result, is(equalTo(true))); } | @Override public boolean requestingStaticFile(HttpServletRequest request) throws MalformedURLException { URL resourceUrl = context.getResource(uriRelativeToContextRoot(request)); return resourceUrl != null && isAFile(resourceUrl); } | DefaultStaticContentHandler implements StaticContentHandler { @Override public boolean requestingStaticFile(HttpServletRequest request) throws MalformedURLException { URL resourceUrl = context.getResource(uriRelativeToContextRoot(request)); return resourceUrl != null && isAFile(resourceUrl); } } | DefaultStaticContentHandler implements StaticContentHandler { @Override public boolean requestingStaticFile(HttpServletRequest request) throws MalformedURLException { URL resourceUrl = context.getResource(uriRelativeToContextRoot(request)); return resourceUrl != null && isAFile(resourceUrl); } protected DefaultStaticContentHandler(); @Inject DefaultStaticContentHandler(ServletContext context); } | DefaultStaticContentHandler implements StaticContentHandler { @Override public boolean requestingStaticFile(HttpServletRequest request) throws MalformedURLException { URL resourceUrl = context.getResource(uriRelativeToContextRoot(request)); return resourceUrl != null && isAFile(resourceUrl); } protected DefaultStaticContentHandler(); @Inject DefaultStaticContentHandler(ServletContext context); @Override boolean requestingStaticFile(HttpServletRequest request); @Override void deferProcessingToContainer(FilterChain filterChain, HttpServletRequest request,
HttpServletResponse response); } | DefaultStaticContentHandler implements StaticContentHandler { @Override public boolean requestingStaticFile(HttpServletRequest request) throws MalformedURLException { URL resourceUrl = context.getResource(uriRelativeToContextRoot(request)); return resourceUrl != null && isAFile(resourceUrl); } protected DefaultStaticContentHandler(); @Inject DefaultStaticContentHandler(ServletContext context); @Override boolean requestingStaticFile(HttpServletRequest request); @Override void deferProcessingToContainer(FilterChain filterChain, HttpServletRequest request,
HttpServletResponse response); } |
@Test public void returnsTrueForRealStaticResourcesWithJSessionId() throws Exception { String key = file.getAbsolutePath(); when(request.getRequestURI()).thenReturn("/contextName/" + key + ";jsesssionid=12lkjahfsd12414"); when(request.getContextPath()).thenReturn("/contextName/"); when(context.getResource(key)).thenReturn(file.toURI().toURL()); boolean result = new DefaultStaticContentHandler(context).requestingStaticFile(request); assertThat(result, is(equalTo(true))); } | @Override public boolean requestingStaticFile(HttpServletRequest request) throws MalformedURLException { URL resourceUrl = context.getResource(uriRelativeToContextRoot(request)); return resourceUrl != null && isAFile(resourceUrl); } | DefaultStaticContentHandler implements StaticContentHandler { @Override public boolean requestingStaticFile(HttpServletRequest request) throws MalformedURLException { URL resourceUrl = context.getResource(uriRelativeToContextRoot(request)); return resourceUrl != null && isAFile(resourceUrl); } } | DefaultStaticContentHandler implements StaticContentHandler { @Override public boolean requestingStaticFile(HttpServletRequest request) throws MalformedURLException { URL resourceUrl = context.getResource(uriRelativeToContextRoot(request)); return resourceUrl != null && isAFile(resourceUrl); } protected DefaultStaticContentHandler(); @Inject DefaultStaticContentHandler(ServletContext context); } | DefaultStaticContentHandler implements StaticContentHandler { @Override public boolean requestingStaticFile(HttpServletRequest request) throws MalformedURLException { URL resourceUrl = context.getResource(uriRelativeToContextRoot(request)); return resourceUrl != null && isAFile(resourceUrl); } protected DefaultStaticContentHandler(); @Inject DefaultStaticContentHandler(ServletContext context); @Override boolean requestingStaticFile(HttpServletRequest request); @Override void deferProcessingToContainer(FilterChain filterChain, HttpServletRequest request,
HttpServletResponse response); } | DefaultStaticContentHandler implements StaticContentHandler { @Override public boolean requestingStaticFile(HttpServletRequest request) throws MalformedURLException { URL resourceUrl = context.getResource(uriRelativeToContextRoot(request)); return resourceUrl != null && isAFile(resourceUrl); } protected DefaultStaticContentHandler(); @Inject DefaultStaticContentHandler(ServletContext context); @Override boolean requestingStaticFile(HttpServletRequest request); @Override void deferProcessingToContainer(FilterChain filterChain, HttpServletRequest request,
HttpServletResponse response); } |
@Test public void returnsFalseForNonStaticResources() throws Exception { String key = "thefile.xml"; when(request.getRequestURI()).thenReturn("/contextName/" + key); when(request.getContextPath()).thenReturn("/contextName/"); when(context.getResource(key)).thenReturn(null); boolean result = new DefaultStaticContentHandler(context).requestingStaticFile(request); assertThat(result, is(equalTo(false))); } | @Override public boolean requestingStaticFile(HttpServletRequest request) throws MalformedURLException { URL resourceUrl = context.getResource(uriRelativeToContextRoot(request)); return resourceUrl != null && isAFile(resourceUrl); } | DefaultStaticContentHandler implements StaticContentHandler { @Override public boolean requestingStaticFile(HttpServletRequest request) throws MalformedURLException { URL resourceUrl = context.getResource(uriRelativeToContextRoot(request)); return resourceUrl != null && isAFile(resourceUrl); } } | DefaultStaticContentHandler implements StaticContentHandler { @Override public boolean requestingStaticFile(HttpServletRequest request) throws MalformedURLException { URL resourceUrl = context.getResource(uriRelativeToContextRoot(request)); return resourceUrl != null && isAFile(resourceUrl); } protected DefaultStaticContentHandler(); @Inject DefaultStaticContentHandler(ServletContext context); } | DefaultStaticContentHandler implements StaticContentHandler { @Override public boolean requestingStaticFile(HttpServletRequest request) throws MalformedURLException { URL resourceUrl = context.getResource(uriRelativeToContextRoot(request)); return resourceUrl != null && isAFile(resourceUrl); } protected DefaultStaticContentHandler(); @Inject DefaultStaticContentHandler(ServletContext context); @Override boolean requestingStaticFile(HttpServletRequest request); @Override void deferProcessingToContainer(FilterChain filterChain, HttpServletRequest request,
HttpServletResponse response); } | DefaultStaticContentHandler implements StaticContentHandler { @Override public boolean requestingStaticFile(HttpServletRequest request) throws MalformedURLException { URL resourceUrl = context.getResource(uriRelativeToContextRoot(request)); return resourceUrl != null && isAFile(resourceUrl); } protected DefaultStaticContentHandler(); @Inject DefaultStaticContentHandler(ServletContext context); @Override boolean requestingStaticFile(HttpServletRequest request); @Override void deferProcessingToContainer(FilterChain filterChain, HttpServletRequest request,
HttpServletResponse response); } |
@Test public void handlerForRegularInterceptorsShouldBeDynamic() throws Exception { assertThat(factory.handlerFor(RegularInterceptor.class), is(instanceOf(ToInstantiateInterceptorHandler.class))); } | @Override public InterceptorHandler handlerFor(final Class<?> type) { return cachedHandlers.fetch(type, new Supplier<InterceptorHandler>() { @Override public InterceptorHandler get() { if(type.isAnnotationPresent(Intercepts.class) && !Interceptor.class.isAssignableFrom(type)){ return new AspectStyleInterceptorHandler(type, stepInvoker, container, customAcceptsExecutor, acceptsExecutor, interceptorExecutor); } return new ToInstantiateInterceptorHandler(container, type, executeMethodExceptionHandler); } }); } | DefaultInterceptorHandlerFactory implements InterceptorHandlerFactory { @Override public InterceptorHandler handlerFor(final Class<?> type) { return cachedHandlers.fetch(type, new Supplier<InterceptorHandler>() { @Override public InterceptorHandler get() { if(type.isAnnotationPresent(Intercepts.class) && !Interceptor.class.isAssignableFrom(type)){ return new AspectStyleInterceptorHandler(type, stepInvoker, container, customAcceptsExecutor, acceptsExecutor, interceptorExecutor); } return new ToInstantiateInterceptorHandler(container, type, executeMethodExceptionHandler); } }); } } | DefaultInterceptorHandlerFactory implements InterceptorHandlerFactory { @Override public InterceptorHandler handlerFor(final Class<?> type) { return cachedHandlers.fetch(type, new Supplier<InterceptorHandler>() { @Override public InterceptorHandler get() { if(type.isAnnotationPresent(Intercepts.class) && !Interceptor.class.isAssignableFrom(type)){ return new AspectStyleInterceptorHandler(type, stepInvoker, container, customAcceptsExecutor, acceptsExecutor, interceptorExecutor); } return new ToInstantiateInterceptorHandler(container, type, executeMethodExceptionHandler); } }); } protected DefaultInterceptorHandlerFactory(); @Inject DefaultInterceptorHandlerFactory(Container container, StepInvoker stepInvoker,
CacheStore<Class<?>, InterceptorHandler> cachedHandlers, InterceptorAcceptsExecutor acceptsExecutor,
CustomAcceptsExecutor customAcceptsExecutor, InterceptorExecutor interceptorExecutor,
ExecuteMethodExceptionHandler executeMethodExceptionHandler); } | DefaultInterceptorHandlerFactory implements InterceptorHandlerFactory { @Override public InterceptorHandler handlerFor(final Class<?> type) { return cachedHandlers.fetch(type, new Supplier<InterceptorHandler>() { @Override public InterceptorHandler get() { if(type.isAnnotationPresent(Intercepts.class) && !Interceptor.class.isAssignableFrom(type)){ return new AspectStyleInterceptorHandler(type, stepInvoker, container, customAcceptsExecutor, acceptsExecutor, interceptorExecutor); } return new ToInstantiateInterceptorHandler(container, type, executeMethodExceptionHandler); } }); } protected DefaultInterceptorHandlerFactory(); @Inject DefaultInterceptorHandlerFactory(Container container, StepInvoker stepInvoker,
CacheStore<Class<?>, InterceptorHandler> cachedHandlers, InterceptorAcceptsExecutor acceptsExecutor,
CustomAcceptsExecutor customAcceptsExecutor, InterceptorExecutor interceptorExecutor,
ExecuteMethodExceptionHandler executeMethodExceptionHandler); @Override InterceptorHandler handlerFor(final Class<?> type); } | DefaultInterceptorHandlerFactory implements InterceptorHandlerFactory { @Override public InterceptorHandler handlerFor(final Class<?> type) { return cachedHandlers.fetch(type, new Supplier<InterceptorHandler>() { @Override public InterceptorHandler get() { if(type.isAnnotationPresent(Intercepts.class) && !Interceptor.class.isAssignableFrom(type)){ return new AspectStyleInterceptorHandler(type, stepInvoker, container, customAcceptsExecutor, acceptsExecutor, interceptorExecutor); } return new ToInstantiateInterceptorHandler(container, type, executeMethodExceptionHandler); } }); } protected DefaultInterceptorHandlerFactory(); @Inject DefaultInterceptorHandlerFactory(Container container, StepInvoker stepInvoker,
CacheStore<Class<?>, InterceptorHandler> cachedHandlers, InterceptorAcceptsExecutor acceptsExecutor,
CustomAcceptsExecutor customAcceptsExecutor, InterceptorExecutor interceptorExecutor,
ExecuteMethodExceptionHandler executeMethodExceptionHandler); @Override InterceptorHandler handlerFor(final Class<?> type); } |
@Test public void handlerForAspectStyleInterceptorsShouldBeDynamic() throws Exception { assertThat(factory.handlerFor(AspectStyleInterceptor.class), is(instanceOf(AspectStyleInterceptorHandler.class))); } | @Override public InterceptorHandler handlerFor(final Class<?> type) { return cachedHandlers.fetch(type, new Supplier<InterceptorHandler>() { @Override public InterceptorHandler get() { if(type.isAnnotationPresent(Intercepts.class) && !Interceptor.class.isAssignableFrom(type)){ return new AspectStyleInterceptorHandler(type, stepInvoker, container, customAcceptsExecutor, acceptsExecutor, interceptorExecutor); } return new ToInstantiateInterceptorHandler(container, type, executeMethodExceptionHandler); } }); } | DefaultInterceptorHandlerFactory implements InterceptorHandlerFactory { @Override public InterceptorHandler handlerFor(final Class<?> type) { return cachedHandlers.fetch(type, new Supplier<InterceptorHandler>() { @Override public InterceptorHandler get() { if(type.isAnnotationPresent(Intercepts.class) && !Interceptor.class.isAssignableFrom(type)){ return new AspectStyleInterceptorHandler(type, stepInvoker, container, customAcceptsExecutor, acceptsExecutor, interceptorExecutor); } return new ToInstantiateInterceptorHandler(container, type, executeMethodExceptionHandler); } }); } } | DefaultInterceptorHandlerFactory implements InterceptorHandlerFactory { @Override public InterceptorHandler handlerFor(final Class<?> type) { return cachedHandlers.fetch(type, new Supplier<InterceptorHandler>() { @Override public InterceptorHandler get() { if(type.isAnnotationPresent(Intercepts.class) && !Interceptor.class.isAssignableFrom(type)){ return new AspectStyleInterceptorHandler(type, stepInvoker, container, customAcceptsExecutor, acceptsExecutor, interceptorExecutor); } return new ToInstantiateInterceptorHandler(container, type, executeMethodExceptionHandler); } }); } protected DefaultInterceptorHandlerFactory(); @Inject DefaultInterceptorHandlerFactory(Container container, StepInvoker stepInvoker,
CacheStore<Class<?>, InterceptorHandler> cachedHandlers, InterceptorAcceptsExecutor acceptsExecutor,
CustomAcceptsExecutor customAcceptsExecutor, InterceptorExecutor interceptorExecutor,
ExecuteMethodExceptionHandler executeMethodExceptionHandler); } | DefaultInterceptorHandlerFactory implements InterceptorHandlerFactory { @Override public InterceptorHandler handlerFor(final Class<?> type) { return cachedHandlers.fetch(type, new Supplier<InterceptorHandler>() { @Override public InterceptorHandler get() { if(type.isAnnotationPresent(Intercepts.class) && !Interceptor.class.isAssignableFrom(type)){ return new AspectStyleInterceptorHandler(type, stepInvoker, container, customAcceptsExecutor, acceptsExecutor, interceptorExecutor); } return new ToInstantiateInterceptorHandler(container, type, executeMethodExceptionHandler); } }); } protected DefaultInterceptorHandlerFactory(); @Inject DefaultInterceptorHandlerFactory(Container container, StepInvoker stepInvoker,
CacheStore<Class<?>, InterceptorHandler> cachedHandlers, InterceptorAcceptsExecutor acceptsExecutor,
CustomAcceptsExecutor customAcceptsExecutor, InterceptorExecutor interceptorExecutor,
ExecuteMethodExceptionHandler executeMethodExceptionHandler); @Override InterceptorHandler handlerFor(final Class<?> type); } | DefaultInterceptorHandlerFactory implements InterceptorHandlerFactory { @Override public InterceptorHandler handlerFor(final Class<?> type) { return cachedHandlers.fetch(type, new Supplier<InterceptorHandler>() { @Override public InterceptorHandler get() { if(type.isAnnotationPresent(Intercepts.class) && !Interceptor.class.isAssignableFrom(type)){ return new AspectStyleInterceptorHandler(type, stepInvoker, container, customAcceptsExecutor, acceptsExecutor, interceptorExecutor); } return new ToInstantiateInterceptorHandler(container, type, executeMethodExceptionHandler); } }); } protected DefaultInterceptorHandlerFactory(); @Inject DefaultInterceptorHandlerFactory(Container container, StepInvoker stepInvoker,
CacheStore<Class<?>, InterceptorHandler> cachedHandlers, InterceptorAcceptsExecutor acceptsExecutor,
CustomAcceptsExecutor customAcceptsExecutor, InterceptorExecutor interceptorExecutor,
ExecuteMethodExceptionHandler executeMethodExceptionHandler); @Override InterceptorHandler handlerFor(final Class<?> type); } |
@Test public void aspectStyleHandlersShouldBeCached() throws Exception { InterceptorHandler handler = factory.handlerFor(AspectStyleInterceptor.class); assertThat(factory.handlerFor(AspectStyleInterceptor.class), is(sameInstance(handler))); } | @Override public InterceptorHandler handlerFor(final Class<?> type) { return cachedHandlers.fetch(type, new Supplier<InterceptorHandler>() { @Override public InterceptorHandler get() { if(type.isAnnotationPresent(Intercepts.class) && !Interceptor.class.isAssignableFrom(type)){ return new AspectStyleInterceptorHandler(type, stepInvoker, container, customAcceptsExecutor, acceptsExecutor, interceptorExecutor); } return new ToInstantiateInterceptorHandler(container, type, executeMethodExceptionHandler); } }); } | DefaultInterceptorHandlerFactory implements InterceptorHandlerFactory { @Override public InterceptorHandler handlerFor(final Class<?> type) { return cachedHandlers.fetch(type, new Supplier<InterceptorHandler>() { @Override public InterceptorHandler get() { if(type.isAnnotationPresent(Intercepts.class) && !Interceptor.class.isAssignableFrom(type)){ return new AspectStyleInterceptorHandler(type, stepInvoker, container, customAcceptsExecutor, acceptsExecutor, interceptorExecutor); } return new ToInstantiateInterceptorHandler(container, type, executeMethodExceptionHandler); } }); } } | DefaultInterceptorHandlerFactory implements InterceptorHandlerFactory { @Override public InterceptorHandler handlerFor(final Class<?> type) { return cachedHandlers.fetch(type, new Supplier<InterceptorHandler>() { @Override public InterceptorHandler get() { if(type.isAnnotationPresent(Intercepts.class) && !Interceptor.class.isAssignableFrom(type)){ return new AspectStyleInterceptorHandler(type, stepInvoker, container, customAcceptsExecutor, acceptsExecutor, interceptorExecutor); } return new ToInstantiateInterceptorHandler(container, type, executeMethodExceptionHandler); } }); } protected DefaultInterceptorHandlerFactory(); @Inject DefaultInterceptorHandlerFactory(Container container, StepInvoker stepInvoker,
CacheStore<Class<?>, InterceptorHandler> cachedHandlers, InterceptorAcceptsExecutor acceptsExecutor,
CustomAcceptsExecutor customAcceptsExecutor, InterceptorExecutor interceptorExecutor,
ExecuteMethodExceptionHandler executeMethodExceptionHandler); } | DefaultInterceptorHandlerFactory implements InterceptorHandlerFactory { @Override public InterceptorHandler handlerFor(final Class<?> type) { return cachedHandlers.fetch(type, new Supplier<InterceptorHandler>() { @Override public InterceptorHandler get() { if(type.isAnnotationPresent(Intercepts.class) && !Interceptor.class.isAssignableFrom(type)){ return new AspectStyleInterceptorHandler(type, stepInvoker, container, customAcceptsExecutor, acceptsExecutor, interceptorExecutor); } return new ToInstantiateInterceptorHandler(container, type, executeMethodExceptionHandler); } }); } protected DefaultInterceptorHandlerFactory(); @Inject DefaultInterceptorHandlerFactory(Container container, StepInvoker stepInvoker,
CacheStore<Class<?>, InterceptorHandler> cachedHandlers, InterceptorAcceptsExecutor acceptsExecutor,
CustomAcceptsExecutor customAcceptsExecutor, InterceptorExecutor interceptorExecutor,
ExecuteMethodExceptionHandler executeMethodExceptionHandler); @Override InterceptorHandler handlerFor(final Class<?> type); } | DefaultInterceptorHandlerFactory implements InterceptorHandlerFactory { @Override public InterceptorHandler handlerFor(final Class<?> type) { return cachedHandlers.fetch(type, new Supplier<InterceptorHandler>() { @Override public InterceptorHandler get() { if(type.isAnnotationPresent(Intercepts.class) && !Interceptor.class.isAssignableFrom(type)){ return new AspectStyleInterceptorHandler(type, stepInvoker, container, customAcceptsExecutor, acceptsExecutor, interceptorExecutor); } return new ToInstantiateInterceptorHandler(container, type, executeMethodExceptionHandler); } }); } protected DefaultInterceptorHandlerFactory(); @Inject DefaultInterceptorHandlerFactory(Container container, StepInvoker stepInvoker,
CacheStore<Class<?>, InterceptorHandler> cachedHandlers, InterceptorAcceptsExecutor acceptsExecutor,
CustomAcceptsExecutor customAcceptsExecutor, InterceptorExecutor interceptorExecutor,
ExecuteMethodExceptionHandler executeMethodExceptionHandler); @Override InterceptorHandler handlerFor(final Class<?> type); } |
@Test public void shouldReplicateMethodParametersToNextRequest() throws Exception { methodInfo.setParameter(0, 1); methodInfo.setParameter(1, 2.0); methodInfo.setParameter(2, 3l); outjector.outjectRequestMap(); verify(result).include("first", 1); verify(result).include("second", 2.0); verify(result).include("third", 3l); } | @Override public void outjectRequestMap() { for (ValuedParameter vparameter : methodInfo.getValuedParameters()) { result.include(vparameter.getName(), vparameter.getValue()); } } | ReplicatorOutjector implements Outjector { @Override public void outjectRequestMap() { for (ValuedParameter vparameter : methodInfo.getValuedParameters()) { result.include(vparameter.getName(), vparameter.getValue()); } } } | ReplicatorOutjector implements Outjector { @Override public void outjectRequestMap() { for (ValuedParameter vparameter : methodInfo.getValuedParameters()) { result.include(vparameter.getName(), vparameter.getValue()); } } protected ReplicatorOutjector(); @Inject ReplicatorOutjector(Result result, MethodInfo method); } | ReplicatorOutjector implements Outjector { @Override public void outjectRequestMap() { for (ValuedParameter vparameter : methodInfo.getValuedParameters()) { result.include(vparameter.getName(), vparameter.getValue()); } } protected ReplicatorOutjector(); @Inject ReplicatorOutjector(Result result, MethodInfo method); @Override void outjectRequestMap(); } | ReplicatorOutjector implements Outjector { @Override public void outjectRequestMap() { for (ValuedParameter vparameter : methodInfo.getValuedParameters()) { result.include(vparameter.getName(), vparameter.getValue()); } } protected ReplicatorOutjector(); @Inject ReplicatorOutjector(Result result, MethodInfo method); @Override void outjectRequestMap(); } |
@Test public void outjectsTheRequestParameters() { try { validator.add(A_MESSAGE); validator.onErrorForwardTo(MyComponent.class).logic(); } catch (ValidationException e) { } verify(outjector).outjectRequestMap(); } | @Override public Validator add(Message message) { message.setBundle(bundle); messages.add(message); return this; } | DefaultValidator extends AbstractValidator { @Override public Validator add(Message message) { message.setBundle(bundle); messages.add(message); return this; } } | DefaultValidator extends AbstractValidator { @Override public Validator add(Message message) { message.setBundle(bundle); messages.add(message); return this; } protected DefaultValidator(); @Inject DefaultValidator(Result result, ValidationViewsFactory factory, Outjector outjector, Proxifier proxifier,
ResourceBundle bundle, javax.validation.Validator bvalidator, MessageInterpolator interpolator, Locale locale,
Messages messages); } | DefaultValidator extends AbstractValidator { @Override public Validator add(Message message) { message.setBundle(bundle); messages.add(message); return this; } protected DefaultValidator(); @Inject DefaultValidator(Result result, ValidationViewsFactory factory, Outjector outjector, Proxifier proxifier,
ResourceBundle bundle, javax.validation.Validator bvalidator, MessageInterpolator interpolator, Locale locale,
Messages messages); @Override Validator check(boolean condition, Message message); @Override Validator ensure(boolean expression, Message message); @Override Validator addIf(boolean expression, Message message); @Override Validator validate(Object object, Class<?>... groups); @Override Validator validate(String alias, Object object, Class<?>... groups); @Override Validator add(Message message); @Override Validator addAll(Collection<? extends Message> messages); @Override Validator addAll(Set<ConstraintViolation<T>> errors); @Override Validator addAll(String alias, Set<ConstraintViolation<T>> errors); @Override T onErrorUse(Class<T> view); @Override boolean hasErrors(); @Override List<Message> getErrors(); } | DefaultValidator extends AbstractValidator { @Override public Validator add(Message message) { message.setBundle(bundle); messages.add(message); return this; } protected DefaultValidator(); @Inject DefaultValidator(Result result, ValidationViewsFactory factory, Outjector outjector, Proxifier proxifier,
ResourceBundle bundle, javax.validation.Validator bvalidator, MessageInterpolator interpolator, Locale locale,
Messages messages); @Override Validator check(boolean condition, Message message); @Override Validator ensure(boolean expression, Message message); @Override Validator addIf(boolean expression, Message message); @Override Validator validate(Object object, Class<?>... groups); @Override Validator validate(String alias, Object object, Class<?>... groups); @Override Validator add(Message message); @Override Validator addAll(Collection<? extends Message> messages); @Override Validator addAll(Set<ConstraintViolation<T>> errors); @Override Validator addAll(String alias, Set<ConstraintViolation<T>> errors); @Override T onErrorUse(Class<T> view); @Override boolean hasErrors(); @Override List<Message> getErrors(); } |
@Test public void dontRegisterRouteIfMethodIsNotPublic() { List<Route> routes = parser.rulesFor(new DefaultBeanClass(ClientsController.class)); Route route = getRouteMatching(routes, "/protectMe"); assertNull(route); } | @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); } |
@Test public void addsTheErrorsOnTheResult() { try { validator.add(A_MESSAGE); validator.onErrorForwardTo(MyComponent.class).logic(); } catch (ValidationException e) { } verify(result).include(eq("errors"), argThat(is(not(empty())))); } | @Override public Validator add(Message message) { message.setBundle(bundle); messages.add(message); return this; } | DefaultValidator extends AbstractValidator { @Override public Validator add(Message message) { message.setBundle(bundle); messages.add(message); return this; } } | DefaultValidator extends AbstractValidator { @Override public Validator add(Message message) { message.setBundle(bundle); messages.add(message); return this; } protected DefaultValidator(); @Inject DefaultValidator(Result result, ValidationViewsFactory factory, Outjector outjector, Proxifier proxifier,
ResourceBundle bundle, javax.validation.Validator bvalidator, MessageInterpolator interpolator, Locale locale,
Messages messages); } | DefaultValidator extends AbstractValidator { @Override public Validator add(Message message) { message.setBundle(bundle); messages.add(message); return this; } protected DefaultValidator(); @Inject DefaultValidator(Result result, ValidationViewsFactory factory, Outjector outjector, Proxifier proxifier,
ResourceBundle bundle, javax.validation.Validator bvalidator, MessageInterpolator interpolator, Locale locale,
Messages messages); @Override Validator check(boolean condition, Message message); @Override Validator ensure(boolean expression, Message message); @Override Validator addIf(boolean expression, Message message); @Override Validator validate(Object object, Class<?>... groups); @Override Validator validate(String alias, Object object, Class<?>... groups); @Override Validator add(Message message); @Override Validator addAll(Collection<? extends Message> messages); @Override Validator addAll(Set<ConstraintViolation<T>> errors); @Override Validator addAll(String alias, Set<ConstraintViolation<T>> errors); @Override T onErrorUse(Class<T> view); @Override boolean hasErrors(); @Override List<Message> getErrors(); } | DefaultValidator extends AbstractValidator { @Override public Validator add(Message message) { message.setBundle(bundle); messages.add(message); return this; } protected DefaultValidator(); @Inject DefaultValidator(Result result, ValidationViewsFactory factory, Outjector outjector, Proxifier proxifier,
ResourceBundle bundle, javax.validation.Validator bvalidator, MessageInterpolator interpolator, Locale locale,
Messages messages); @Override Validator check(boolean condition, Message message); @Override Validator ensure(boolean expression, Message message); @Override Validator addIf(boolean expression, Message message); @Override Validator validate(Object object, Class<?>... groups); @Override Validator validate(String alias, Object object, Class<?>... groups); @Override Validator add(Message message); @Override Validator addAll(Collection<? extends Message> messages); @Override Validator addAll(Set<ConstraintViolation<T>> errors); @Override Validator addAll(String alias, Set<ConstraintViolation<T>> errors); @Override T onErrorUse(Class<T> view); @Override boolean hasErrors(); @Override List<Message> getErrors(); } |
@Test public void forwardToCustomOnErrorPage() { try { when(logicResult.forwardTo(MyComponent.class)).thenReturn(instance); validator.add(A_MESSAGE); validator.onErrorForwardTo(MyComponent.class).logic(); fail("should stop flow"); } catch (ValidationException e) { verify(instance).logic(); } } | @Override public Validator add(Message message) { message.setBundle(bundle); messages.add(message); return this; } | DefaultValidator extends AbstractValidator { @Override public Validator add(Message message) { message.setBundle(bundle); messages.add(message); return this; } } | DefaultValidator extends AbstractValidator { @Override public Validator add(Message message) { message.setBundle(bundle); messages.add(message); return this; } protected DefaultValidator(); @Inject DefaultValidator(Result result, ValidationViewsFactory factory, Outjector outjector, Proxifier proxifier,
ResourceBundle bundle, javax.validation.Validator bvalidator, MessageInterpolator interpolator, Locale locale,
Messages messages); } | DefaultValidator extends AbstractValidator { @Override public Validator add(Message message) { message.setBundle(bundle); messages.add(message); return this; } protected DefaultValidator(); @Inject DefaultValidator(Result result, ValidationViewsFactory factory, Outjector outjector, Proxifier proxifier,
ResourceBundle bundle, javax.validation.Validator bvalidator, MessageInterpolator interpolator, Locale locale,
Messages messages); @Override Validator check(boolean condition, Message message); @Override Validator ensure(boolean expression, Message message); @Override Validator addIf(boolean expression, Message message); @Override Validator validate(Object object, Class<?>... groups); @Override Validator validate(String alias, Object object, Class<?>... groups); @Override Validator add(Message message); @Override Validator addAll(Collection<? extends Message> messages); @Override Validator addAll(Set<ConstraintViolation<T>> errors); @Override Validator addAll(String alias, Set<ConstraintViolation<T>> errors); @Override T onErrorUse(Class<T> view); @Override boolean hasErrors(); @Override List<Message> getErrors(); } | DefaultValidator extends AbstractValidator { @Override public Validator add(Message message) { message.setBundle(bundle); messages.add(message); return this; } protected DefaultValidator(); @Inject DefaultValidator(Result result, ValidationViewsFactory factory, Outjector outjector, Proxifier proxifier,
ResourceBundle bundle, javax.validation.Validator bvalidator, MessageInterpolator interpolator, Locale locale,
Messages messages); @Override Validator check(boolean condition, Message message); @Override Validator ensure(boolean expression, Message message); @Override Validator addIf(boolean expression, Message message); @Override Validator validate(Object object, Class<?>... groups); @Override Validator validate(String alias, Object object, Class<?>... groups); @Override Validator add(Message message); @Override Validator addAll(Collection<? extends Message> messages); @Override Validator addAll(Set<ConstraintViolation<T>> errors); @Override Validator addAll(String alias, Set<ConstraintViolation<T>> errors); @Override T onErrorUse(Class<T> view); @Override boolean hasErrors(); @Override List<Message> getErrors(); } |
@Test public void shouldNotRedirectIfHasNotErrors() { try { validator.onErrorRedirectTo(MyComponent.class).logic(); assertThat(validator.getErrors(), hasSize(0)); verify(outjector, never()).outjectRequestMap(); } catch (ValidationException e) { fail("no error occurs"); } } | @Override public List<Message> getErrors() { return messages.getErrors(); } | DefaultValidator extends AbstractValidator { @Override public List<Message> getErrors() { return messages.getErrors(); } } | DefaultValidator extends AbstractValidator { @Override public List<Message> getErrors() { return messages.getErrors(); } protected DefaultValidator(); @Inject DefaultValidator(Result result, ValidationViewsFactory factory, Outjector outjector, Proxifier proxifier,
ResourceBundle bundle, javax.validation.Validator bvalidator, MessageInterpolator interpolator, Locale locale,
Messages messages); } | DefaultValidator extends AbstractValidator { @Override public List<Message> getErrors() { return messages.getErrors(); } protected DefaultValidator(); @Inject DefaultValidator(Result result, ValidationViewsFactory factory, Outjector outjector, Proxifier proxifier,
ResourceBundle bundle, javax.validation.Validator bvalidator, MessageInterpolator interpolator, Locale locale,
Messages messages); @Override Validator check(boolean condition, Message message); @Override Validator ensure(boolean expression, Message message); @Override Validator addIf(boolean expression, Message message); @Override Validator validate(Object object, Class<?>... groups); @Override Validator validate(String alias, Object object, Class<?>... groups); @Override Validator add(Message message); @Override Validator addAll(Collection<? extends Message> messages); @Override Validator addAll(Set<ConstraintViolation<T>> errors); @Override Validator addAll(String alias, Set<ConstraintViolation<T>> errors); @Override T onErrorUse(Class<T> view); @Override boolean hasErrors(); @Override List<Message> getErrors(); } | DefaultValidator extends AbstractValidator { @Override public List<Message> getErrors() { return messages.getErrors(); } protected DefaultValidator(); @Inject DefaultValidator(Result result, ValidationViewsFactory factory, Outjector outjector, Proxifier proxifier,
ResourceBundle bundle, javax.validation.Validator bvalidator, MessageInterpolator interpolator, Locale locale,
Messages messages); @Override Validator check(boolean condition, Message message); @Override Validator ensure(boolean expression, Message message); @Override Validator addIf(boolean expression, Message message); @Override Validator validate(Object object, Class<?>... groups); @Override Validator validate(String alias, Object object, Class<?>... groups); @Override Validator add(Message message); @Override Validator addAll(Collection<? extends Message> messages); @Override Validator addAll(Set<ConstraintViolation<T>> errors); @Override Validator addAll(String alias, Set<ConstraintViolation<T>> errors); @Override T onErrorUse(Class<T> view); @Override boolean hasErrors(); @Override List<Message> getErrors(); } |
@Test public void testThatValidatorGoToRedirectsToTheErrorPageImmediatellyAndNotBeforeThis() { try { validator.addAll(Arrays.asList(new SimpleMessage("test", "test"))); when(pageResult.of(MyComponent.class)).thenReturn(instance); validator.onErrorUsePageOf(MyComponent.class).logic(); fail("should stop flow"); } catch (ValidationException e) { verify(instance).logic(); } } | @Override public Validator addAll(Collection<? extends Message> messages) { for (Message message : messages) { add(message); } return this; } | DefaultValidator extends AbstractValidator { @Override public Validator addAll(Collection<? extends Message> messages) { for (Message message : messages) { add(message); } return this; } } | DefaultValidator extends AbstractValidator { @Override public Validator addAll(Collection<? extends Message> messages) { for (Message message : messages) { add(message); } return this; } protected DefaultValidator(); @Inject DefaultValidator(Result result, ValidationViewsFactory factory, Outjector outjector, Proxifier proxifier,
ResourceBundle bundle, javax.validation.Validator bvalidator, MessageInterpolator interpolator, Locale locale,
Messages messages); } | DefaultValidator extends AbstractValidator { @Override public Validator addAll(Collection<? extends Message> messages) { for (Message message : messages) { add(message); } return this; } protected DefaultValidator(); @Inject DefaultValidator(Result result, ValidationViewsFactory factory, Outjector outjector, Proxifier proxifier,
ResourceBundle bundle, javax.validation.Validator bvalidator, MessageInterpolator interpolator, Locale locale,
Messages messages); @Override Validator check(boolean condition, Message message); @Override Validator ensure(boolean expression, Message message); @Override Validator addIf(boolean expression, Message message); @Override Validator validate(Object object, Class<?>... groups); @Override Validator validate(String alias, Object object, Class<?>... groups); @Override Validator add(Message message); @Override Validator addAll(Collection<? extends Message> messages); @Override Validator addAll(Set<ConstraintViolation<T>> errors); @Override Validator addAll(String alias, Set<ConstraintViolation<T>> errors); @Override T onErrorUse(Class<T> view); @Override boolean hasErrors(); @Override List<Message> getErrors(); } | DefaultValidator extends AbstractValidator { @Override public Validator addAll(Collection<? extends Message> messages) { for (Message message : messages) { add(message); } return this; } protected DefaultValidator(); @Inject DefaultValidator(Result result, ValidationViewsFactory factory, Outjector outjector, Proxifier proxifier,
ResourceBundle bundle, javax.validation.Validator bvalidator, MessageInterpolator interpolator, Locale locale,
Messages messages); @Override Validator check(boolean condition, Message message); @Override Validator ensure(boolean expression, Message message); @Override Validator addIf(boolean expression, Message message); @Override Validator validate(Object object, Class<?>... groups); @Override Validator validate(String alias, Object object, Class<?>... groups); @Override Validator add(Message message); @Override Validator addAll(Collection<? extends Message> messages); @Override Validator addAll(Set<ConstraintViolation<T>> errors); @Override Validator addAll(String alias, Set<ConstraintViolation<T>> errors); @Override T onErrorUse(Class<T> view); @Override boolean hasErrors(); @Override List<Message> getErrors(); } |
@Test public void shouldNotThrowExceptionIfMessagesHasNoErrors() { messages.assertAbsenceOfErrors(); } | public void assertAbsenceOfErrors() { if (hasUnhandledErrors()) { log.debug("Some validation errors occured: {}", getErrors()); throw new ValidationFailedException( "There are validation errors and you forgot to specify where to go. Please add in your method " + "something like:\n" + "validator.onErrorUse(page()).of(AnyController.class).anyMethod();\n" + "or any view that you like.\n" + "If you didn't add any validation error, it is possible that a conversion error had happened."); } } | Messages implements Serializable { public void assertAbsenceOfErrors() { if (hasUnhandledErrors()) { log.debug("Some validation errors occured: {}", getErrors()); throw new ValidationFailedException( "There are validation errors and you forgot to specify where to go. Please add in your method " + "something like:\n" + "validator.onErrorUse(page()).of(AnyController.class).anyMethod();\n" + "or any view that you like.\n" + "If you didn't add any validation error, it is possible that a conversion error had happened."); } } } | Messages implements Serializable { public void assertAbsenceOfErrors() { if (hasUnhandledErrors()) { log.debug("Some validation errors occured: {}", getErrors()); throw new ValidationFailedException( "There are validation errors and you forgot to specify where to go. Please add in your method " + "something like:\n" + "validator.onErrorUse(page()).of(AnyController.class).anyMethod();\n" + "or any view that you like.\n" + "If you didn't add any validation error, it is possible that a conversion error had happened."); } } } | Messages implements Serializable { public void assertAbsenceOfErrors() { if (hasUnhandledErrors()) { log.debug("Some validation errors occured: {}", getErrors()); throw new ValidationFailedException( "There are validation errors and you forgot to specify where to go. Please add in your method " + "something like:\n" + "validator.onErrorUse(page()).of(AnyController.class).anyMethod();\n" + "or any view that you like.\n" + "If you didn't add any validation error, it is possible that a conversion error had happened."); } } Messages add(Message message); List<Message> getErrors(); List<Message> getInfo(); List<Message> getWarnings(); List<Message> getSuccess(); List<Message> getAll(); List<Message> handleErrors(); boolean hasUnhandledErrors(); void assertAbsenceOfErrors(); } | Messages implements Serializable { public void assertAbsenceOfErrors() { if (hasUnhandledErrors()) { log.debug("Some validation errors occured: {}", getErrors()); throw new ValidationFailedException( "There are validation errors and you forgot to specify where to go. Please add in your method " + "something like:\n" + "validator.onErrorUse(page()).of(AnyController.class).anyMethod();\n" + "or any view that you like.\n" + "If you didn't add any validation error, it is possible that a conversion error had happened."); } } Messages add(Message message); List<Message> getErrors(); List<Message> getInfo(); List<Message> getWarnings(); List<Message> getSuccess(); List<Message> getAll(); List<Message> handleErrors(); boolean hasUnhandledErrors(); void assertAbsenceOfErrors(); } |
@Test public void testElExpressionGettingMessagesByCaegory() { messages.add(new SimpleMessage("client.id", "will generated", Severity.INFO)); messages.add(new SimpleMessage("client.name", "not null")); messages.add(new SimpleMessage("client.name", "not empty")); ELProcessor el = new ELProcessor(); el.defineBean("messages", messages); String result = el.eval("messages.errors.from('client.name')").toString(); assertThat(result, is("not null, not empty")); result = el.eval("messages.errors.from('client.name').join(' - ')").toString(); assertThat(result, is("not null - not empty")); result = el.eval("messages.errors.from('client.id')").toString(); assertThat(result, isEmptyString()); result = el.eval("messages.info.from('client.id')").toString(); assertThat(result, is("will generated")); } | public Messages add(Message message) { get(message.getSeverity()).add(message); if(Severity.ERROR.equals(message.getSeverity())) { unhandledErrors = true; } return this; } | Messages implements Serializable { public Messages add(Message message) { get(message.getSeverity()).add(message); if(Severity.ERROR.equals(message.getSeverity())) { unhandledErrors = true; } return this; } } | Messages implements Serializable { public Messages add(Message message) { get(message.getSeverity()).add(message); if(Severity.ERROR.equals(message.getSeverity())) { unhandledErrors = true; } return this; } } | Messages implements Serializable { public Messages add(Message message) { get(message.getSeverity()).add(message); if(Severity.ERROR.equals(message.getSeverity())) { unhandledErrors = true; } return this; } Messages add(Message message); List<Message> getErrors(); List<Message> getInfo(); List<Message> getWarnings(); List<Message> getSuccess(); List<Message> getAll(); List<Message> handleErrors(); boolean hasUnhandledErrors(); void assertAbsenceOfErrors(); } | Messages implements Serializable { public Messages add(Message message) { get(message.getSeverity()).add(message); if(Severity.ERROR.equals(message.getSeverity())) { unhandledErrors = true; } return this; } Messages add(Message message); List<Message> getErrors(); List<Message> getInfo(); List<Message> getWarnings(); List<Message> getSuccess(); List<Message> getAll(); List<Message> handleErrors(); boolean hasUnhandledErrors(); void assertAbsenceOfErrors(); } |
@Test public void shouldBeAbleToConvert() throws ParseException { assertThat(converter.convert("10/06/2008", Date.class), is(equalTo(new SimpleDateFormat("dd/MM/yyyy") .parse("10/06/2008")))); } | @Override public Date convert(String value, Class<? extends Date> type) { if (isNullOrEmpty(value)) { return null; } try { return getDateFormat().parse(value); } catch (ParseException pe) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } | DateConverter implements Converter<Date> { @Override public Date convert(String value, Class<? extends Date> type) { if (isNullOrEmpty(value)) { return null; } try { return getDateFormat().parse(value); } catch (ParseException pe) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } } | DateConverter implements Converter<Date> { @Override public Date convert(String value, Class<? extends Date> type) { if (isNullOrEmpty(value)) { return null; } try { return getDateFormat().parse(value); } catch (ParseException pe) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DateConverter(); @Inject DateConverter(Locale locale); } | DateConverter implements Converter<Date> { @Override public Date convert(String value, Class<? extends Date> type) { if (isNullOrEmpty(value)) { return null; } try { return getDateFormat().parse(value); } catch (ParseException pe) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DateConverter(); @Inject DateConverter(Locale locale); @Override Date convert(String value, Class<? extends Date> type); } | DateConverter implements Converter<Date> { @Override public Date convert(String value, Class<? extends Date> type) { if (isNullOrEmpty(value)) { return null; } try { return getDateFormat().parse(value); } catch (ParseException pe) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DateConverter(); @Inject DateConverter(Locale locale); @Override Date convert(String value, Class<? extends Date> type); static final String INVALID_MESSAGE_KEY; } |
@Test public void shouldBeAbleToConvertEmpty() { assertThat(converter.convert("", Date.class), is(nullValue())); } | @Override public Date convert(String value, Class<? extends Date> type) { if (isNullOrEmpty(value)) { return null; } try { return getDateFormat().parse(value); } catch (ParseException pe) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } | DateConverter implements Converter<Date> { @Override public Date convert(String value, Class<? extends Date> type) { if (isNullOrEmpty(value)) { return null; } try { return getDateFormat().parse(value); } catch (ParseException pe) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } } | DateConverter implements Converter<Date> { @Override public Date convert(String value, Class<? extends Date> type) { if (isNullOrEmpty(value)) { return null; } try { return getDateFormat().parse(value); } catch (ParseException pe) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DateConverter(); @Inject DateConverter(Locale locale); } | DateConverter implements Converter<Date> { @Override public Date convert(String value, Class<? extends Date> type) { if (isNullOrEmpty(value)) { return null; } try { return getDateFormat().parse(value); } catch (ParseException pe) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DateConverter(); @Inject DateConverter(Locale locale); @Override Date convert(String value, Class<? extends Date> type); } | DateConverter implements Converter<Date> { @Override public Date convert(String value, Class<? extends Date> type) { if (isNullOrEmpty(value)) { return null; } try { return getDateFormat().parse(value); } catch (ParseException pe) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DateConverter(); @Inject DateConverter(Locale locale); @Override Date convert(String value, Class<? extends Date> type); static final String INVALID_MESSAGE_KEY; } |
@Test public void shouldBeAbleToConvertNull() { assertThat(converter.convert(null, Date.class), is(nullValue())); } | @Override public Date convert(String value, Class<? extends Date> type) { if (isNullOrEmpty(value)) { return null; } try { return getDateFormat().parse(value); } catch (ParseException pe) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } | DateConverter implements Converter<Date> { @Override public Date convert(String value, Class<? extends Date> type) { if (isNullOrEmpty(value)) { return null; } try { return getDateFormat().parse(value); } catch (ParseException pe) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } } | DateConverter implements Converter<Date> { @Override public Date convert(String value, Class<? extends Date> type) { if (isNullOrEmpty(value)) { return null; } try { return getDateFormat().parse(value); } catch (ParseException pe) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DateConverter(); @Inject DateConverter(Locale locale); } | DateConverter implements Converter<Date> { @Override public Date convert(String value, Class<? extends Date> type) { if (isNullOrEmpty(value)) { return null; } try { return getDateFormat().parse(value); } catch (ParseException pe) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DateConverter(); @Inject DateConverter(Locale locale); @Override Date convert(String value, Class<? extends Date> type); } | DateConverter implements Converter<Date> { @Override public Date convert(String value, Class<? extends Date> type) { if (isNullOrEmpty(value)) { return null; } try { return getDateFormat().parse(value); } catch (ParseException pe) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DateConverter(); @Inject DateConverter(Locale locale); @Override Date convert(String value, Class<? extends Date> type); static final String INVALID_MESSAGE_KEY; } |
@Test public void shouldThrowExceptionWhenUnableToParse() { exception.expect(hasConversionException("a,10/06/2008/a/b/c is not a valid date.")); converter.convert("a,10/06/2008/a/b/c", Date.class); } | @Override public Date convert(String value, Class<? extends Date> type) { if (isNullOrEmpty(value)) { return null; } try { return getDateFormat().parse(value); } catch (ParseException pe) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } | DateConverter implements Converter<Date> { @Override public Date convert(String value, Class<? extends Date> type) { if (isNullOrEmpty(value)) { return null; } try { return getDateFormat().parse(value); } catch (ParseException pe) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } } | DateConverter implements Converter<Date> { @Override public Date convert(String value, Class<? extends Date> type) { if (isNullOrEmpty(value)) { return null; } try { return getDateFormat().parse(value); } catch (ParseException pe) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DateConverter(); @Inject DateConverter(Locale locale); } | DateConverter implements Converter<Date> { @Override public Date convert(String value, Class<? extends Date> type) { if (isNullOrEmpty(value)) { return null; } try { return getDateFormat().parse(value); } catch (ParseException pe) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DateConverter(); @Inject DateConverter(Locale locale); @Override Date convert(String value, Class<? extends Date> type); } | DateConverter implements Converter<Date> { @Override public Date convert(String value, Class<? extends Date> type) { if (isNullOrEmpty(value)) { return null; } try { return getDateFormat().parse(value); } catch (ParseException pe) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DateConverter(); @Inject DateConverter(Locale locale); @Override Date convert(String value, Class<? extends Date> type); static final String INVALID_MESSAGE_KEY; } |
@Test public void dontRegisterRouteIfMethodIsStatic() { List<Route> routes = parser.rulesFor(new DefaultBeanClass(ClientsController.class)); Route route = getRouteMatching(routes, "/staticMe"); assertNull(route); } | @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); } |
@Test public void shouldBeAbleToConvertNumbers() { assertThat(converter.convert("2", long.class), is(equalTo(2L))); } | @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return 0L; } try { return Long.parseLong(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } | PrimitiveLongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return 0L; } try { return Long.parseLong(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } } | PrimitiveLongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return 0L; } try { return Long.parseLong(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } } | PrimitiveLongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return 0L; } try { return Long.parseLong(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Long convert(String value, Class<? extends Long> type); } | PrimitiveLongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return 0L; } try { return Long.parseLong(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Long convert(String value, Class<? extends Long> type); static final String INVALID_MESSAGE_KEY; } |
@Test public void shouldComplainAboutInvalidNumber() { exception.expect(hasConversionException("--- is not a valid number.")); converter.convert("---", long.class); } | @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return 0L; } try { return Long.parseLong(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } | PrimitiveLongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return 0L; } try { return Long.parseLong(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } } | PrimitiveLongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return 0L; } try { return Long.parseLong(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } } | PrimitiveLongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return 0L; } try { return Long.parseLong(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Long convert(String value, Class<? extends Long> type); } | PrimitiveLongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return 0L; } try { return Long.parseLong(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Long convert(String value, Class<? extends Long> type); static final String INVALID_MESSAGE_KEY; } |
@Test public void shouldConvertToZeroWhenNull() { assertThat(converter.convert(null, long.class), is(equalTo(0L))); } | @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return 0L; } try { return Long.parseLong(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } | PrimitiveLongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return 0L; } try { return Long.parseLong(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } } | PrimitiveLongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return 0L; } try { return Long.parseLong(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } } | PrimitiveLongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return 0L; } try { return Long.parseLong(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Long convert(String value, Class<? extends Long> type); } | PrimitiveLongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return 0L; } try { return Long.parseLong(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Long convert(String value, Class<? extends Long> type); static final String INVALID_MESSAGE_KEY; } |
@Test public void shouldConvertToZeroWhenEmpty() { assertThat(converter.convert("", long.class), is(equalTo(0L))); } | @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return 0L; } try { return Long.parseLong(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } | PrimitiveLongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return 0L; } try { return Long.parseLong(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } } | PrimitiveLongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return 0L; } try { return Long.parseLong(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } } | PrimitiveLongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return 0L; } try { return Long.parseLong(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Long convert(String value, Class<? extends Long> type); } | PrimitiveLongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return 0L; } try { return Long.parseLong(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Long convert(String value, Class<? extends Long> type); static final String INVALID_MESSAGE_KEY; } |
@Test public void shouldBeAbleToConvertNumbers() { assertThat(converter.convert("", boolean.class), is(equalTo(false))); assertThat(converter.convert("false", boolean.class), is(equalTo(false))); assertThat(converter.convert("true", boolean.class), is(equalTo(true))); assertThat(converter.convert("True", boolean.class), is(equalTo(true))); } | @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); @Override Boolean convert(String value, Class<? extends Boolean> type); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); @Override Boolean convert(String value, Class<? extends Boolean> type); } |
@Test public void shouldConvertToZeroWhenNull() { assertThat(converter.convert(null, boolean.class), is(equalTo(false))); } | @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); @Override Boolean convert(String value, Class<? extends Boolean> type); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); @Override Boolean convert(String value, Class<? extends Boolean> type); } |
@Test public void shouldConvertToZeroWhenEmpty() { assertThat(converter.convert("", boolean.class), is(equalTo(false))); } | @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); @Override Boolean convert(String value, Class<? extends Boolean> type); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); @Override Boolean convert(String value, Class<? extends Boolean> type); } |
@Test public void shouldConvertYesNo() { assertThat(converter.convert("yes", boolean.class), is(equalTo(true))); assertThat(converter.convert("no", boolean.class), is(equalTo(false))); } | @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); @Override Boolean convert(String value, Class<? extends Boolean> type); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); @Override Boolean convert(String value, Class<? extends Boolean> type); } |
@Test public void shouldConvertYN() { assertThat(converter.convert("y", boolean.class), is(equalTo(true))); assertThat(converter.convert("n", boolean.class), is(equalTo(false))); } | @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); @Override Boolean convert(String value, Class<? extends Boolean> type); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); @Override Boolean convert(String value, Class<? extends Boolean> type); } |
@Test public void shouldConvertOnOff() { assertThat(converter.convert("on", boolean.class), is(equalTo(true))); assertThat(converter.convert("off", boolean.class), is(equalTo(false))); } | @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); @Override Boolean convert(String value, Class<? extends Boolean> type); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); @Override Boolean convert(String value, Class<? extends Boolean> type); } |
@Test public void shouldThrowExceptionIfPathAnnotationHasEmptyArray() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage(containsString("You must specify at least one path on @Path at")); parser.rulesFor(new DefaultBeanClass(NoPath.class)); } | @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); } | PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); } |
@Test public void returnsNullIfNotFound() { assertThat(vraptor.getParameter("minimum"), is(nullValue())); } | @Override public String getParameter(String name) { if (extraParameters.containsKey(name)) { return extraParameters.get(name)[0]; } return super.getParameter(name); } | VRaptorRequest extends HttpServletRequestWrapper implements MutableRequest { @Override public String getParameter(String name) { if (extraParameters.containsKey(name)) { return extraParameters.get(name)[0]; } return super.getParameter(name); } } | VRaptorRequest extends HttpServletRequestWrapper implements MutableRequest { @Override public String getParameter(String name) { if (extraParameters.containsKey(name)) { return extraParameters.get(name)[0]; } return super.getParameter(name); } VRaptorRequest(HttpServletRequest request); } | VRaptorRequest extends HttpServletRequestWrapper implements MutableRequest { @Override public String getParameter(String name) { if (extraParameters.containsKey(name)) { return extraParameters.get(name)[0]; } return super.getParameter(name); } VRaptorRequest(HttpServletRequest request); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String key, String... value); @Override String getRequestedUri(); static String getRelativeRequestURI(HttpServletRequest request); @Override String toString(); } | VRaptorRequest extends HttpServletRequestWrapper implements MutableRequest { @Override public String getParameter(String name) { if (extraParameters.containsKey(name)) { return extraParameters.get(name)[0]; } return super.getParameter(name); } VRaptorRequest(HttpServletRequest request); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String key, String... value); @Override String getRequestedUri(); static String getRelativeRequestURI(HttpServletRequest request); @Override String toString(); } |
@Test public void shouldConvertIgnoringCase() { assertThat(converter.convert("truE", boolean.class), is(equalTo(true))); assertThat(converter.convert("FALSE", boolean.class), is(equalTo(false))); assertThat(converter.convert("On", boolean.class), is(equalTo(true))); assertThat(converter.convert("oFf", boolean.class), is(equalTo(false))); } | @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); @Override Boolean convert(String value, Class<? extends Boolean> type); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); @Override Boolean convert(String value, Class<? extends Boolean> type); } |
@Test public void shouldThrowExceptionForInvalidString() { exception.expect(hasConversionException("NOT A BOOLEAN! is not a valid boolean. Please use true/false, yes/no, y/n or on/off")); converter.convert("not a boolean!", boolean.class); } | @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); @Override Boolean convert(String value, Class<? extends Boolean> type); } | PrimitiveBooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return false; } return booleanConverter.convert(value, type); } protected PrimitiveBooleanConverter(); @Inject PrimitiveBooleanConverter(BooleanConverter converter); @Override Boolean convert(String value, Class<? extends Boolean> type); } |
@Test public void shouldBeAbleToConvert() { Calendar expected = Calendar.getInstance(new Locale("pt", "BR")); expected.set(2008, 5, 10, 0, 0, 0); expected.set(Calendar.MILLISECOND, 0); assertThat(converter.convert("10/06/2008", Calendar.class), is(equalTo(expected))); } | @Override public Calendar convert(String value, Class<? extends Calendar> type) { if (isNullOrEmpty(value)) { return null; } try { Date date = getDateFormat().parse(value); Calendar calendar = Calendar.getInstance(locale); calendar.setTime(date); return calendar; } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } | CalendarConverter implements Converter<Calendar> { @Override public Calendar convert(String value, Class<? extends Calendar> type) { if (isNullOrEmpty(value)) { return null; } try { Date date = getDateFormat().parse(value); Calendar calendar = Calendar.getInstance(locale); calendar.setTime(date); return calendar; } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } } | CalendarConverter implements Converter<Calendar> { @Override public Calendar convert(String value, Class<? extends Calendar> type) { if (isNullOrEmpty(value)) { return null; } try { Date date = getDateFormat().parse(value); Calendar calendar = Calendar.getInstance(locale); calendar.setTime(date); return calendar; } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected CalendarConverter(); @Inject CalendarConverter(Locale locale); } | CalendarConverter implements Converter<Calendar> { @Override public Calendar convert(String value, Class<? extends Calendar> type) { if (isNullOrEmpty(value)) { return null; } try { Date date = getDateFormat().parse(value); Calendar calendar = Calendar.getInstance(locale); calendar.setTime(date); return calendar; } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected CalendarConverter(); @Inject CalendarConverter(Locale locale); @Override Calendar convert(String value, Class<? extends Calendar> type); } | CalendarConverter implements Converter<Calendar> { @Override public Calendar convert(String value, Class<? extends Calendar> type) { if (isNullOrEmpty(value)) { return null; } try { Date date = getDateFormat().parse(value); Calendar calendar = Calendar.getInstance(locale); calendar.setTime(date); return calendar; } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected CalendarConverter(); @Inject CalendarConverter(Locale locale); @Override Calendar convert(String value, Class<? extends Calendar> type); static final String INVALID_MESSAGE_KEY; } |
@Test public void shouldBeAbleToConvertEmpty() { assertThat(converter.convert("", Calendar.class), is(nullValue())); } | @Override public Calendar convert(String value, Class<? extends Calendar> type) { if (isNullOrEmpty(value)) { return null; } try { Date date = getDateFormat().parse(value); Calendar calendar = Calendar.getInstance(locale); calendar.setTime(date); return calendar; } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } | CalendarConverter implements Converter<Calendar> { @Override public Calendar convert(String value, Class<? extends Calendar> type) { if (isNullOrEmpty(value)) { return null; } try { Date date = getDateFormat().parse(value); Calendar calendar = Calendar.getInstance(locale); calendar.setTime(date); return calendar; } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } } | CalendarConverter implements Converter<Calendar> { @Override public Calendar convert(String value, Class<? extends Calendar> type) { if (isNullOrEmpty(value)) { return null; } try { Date date = getDateFormat().parse(value); Calendar calendar = Calendar.getInstance(locale); calendar.setTime(date); return calendar; } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected CalendarConverter(); @Inject CalendarConverter(Locale locale); } | CalendarConverter implements Converter<Calendar> { @Override public Calendar convert(String value, Class<? extends Calendar> type) { if (isNullOrEmpty(value)) { return null; } try { Date date = getDateFormat().parse(value); Calendar calendar = Calendar.getInstance(locale); calendar.setTime(date); return calendar; } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected CalendarConverter(); @Inject CalendarConverter(Locale locale); @Override Calendar convert(String value, Class<? extends Calendar> type); } | CalendarConverter implements Converter<Calendar> { @Override public Calendar convert(String value, Class<? extends Calendar> type) { if (isNullOrEmpty(value)) { return null; } try { Date date = getDateFormat().parse(value); Calendar calendar = Calendar.getInstance(locale); calendar.setTime(date); return calendar; } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected CalendarConverter(); @Inject CalendarConverter(Locale locale); @Override Calendar convert(String value, Class<? extends Calendar> type); static final String INVALID_MESSAGE_KEY; } |
@Test public void shouldBeAbleToConvertNull() { assertThat(converter.convert(null, Calendar.class), is(nullValue())); } | @Override public Calendar convert(String value, Class<? extends Calendar> type) { if (isNullOrEmpty(value)) { return null; } try { Date date = getDateFormat().parse(value); Calendar calendar = Calendar.getInstance(locale); calendar.setTime(date); return calendar; } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } | CalendarConverter implements Converter<Calendar> { @Override public Calendar convert(String value, Class<? extends Calendar> type) { if (isNullOrEmpty(value)) { return null; } try { Date date = getDateFormat().parse(value); Calendar calendar = Calendar.getInstance(locale); calendar.setTime(date); return calendar; } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } } | CalendarConverter implements Converter<Calendar> { @Override public Calendar convert(String value, Class<? extends Calendar> type) { if (isNullOrEmpty(value)) { return null; } try { Date date = getDateFormat().parse(value); Calendar calendar = Calendar.getInstance(locale); calendar.setTime(date); return calendar; } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected CalendarConverter(); @Inject CalendarConverter(Locale locale); } | CalendarConverter implements Converter<Calendar> { @Override public Calendar convert(String value, Class<? extends Calendar> type) { if (isNullOrEmpty(value)) { return null; } try { Date date = getDateFormat().parse(value); Calendar calendar = Calendar.getInstance(locale); calendar.setTime(date); return calendar; } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected CalendarConverter(); @Inject CalendarConverter(Locale locale); @Override Calendar convert(String value, Class<? extends Calendar> type); } | CalendarConverter implements Converter<Calendar> { @Override public Calendar convert(String value, Class<? extends Calendar> type) { if (isNullOrEmpty(value)) { return null; } try { Date date = getDateFormat().parse(value); Calendar calendar = Calendar.getInstance(locale); calendar.setTime(date); return calendar; } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected CalendarConverter(); @Inject CalendarConverter(Locale locale); @Override Calendar convert(String value, Class<? extends Calendar> type); static final String INVALID_MESSAGE_KEY; } |
@Test public void shouldThrowExceptionWhenUnableToParse() { exception.expect(hasConversionException("a,10/06/2008/a/b/c is not a valid date.")); converter.convert("a,10/06/2008/a/b/c", Calendar.class); } | @Override public Calendar convert(String value, Class<? extends Calendar> type) { if (isNullOrEmpty(value)) { return null; } try { Date date = getDateFormat().parse(value); Calendar calendar = Calendar.getInstance(locale); calendar.setTime(date); return calendar; } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } | CalendarConverter implements Converter<Calendar> { @Override public Calendar convert(String value, Class<? extends Calendar> type) { if (isNullOrEmpty(value)) { return null; } try { Date date = getDateFormat().parse(value); Calendar calendar = Calendar.getInstance(locale); calendar.setTime(date); return calendar; } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } } | CalendarConverter implements Converter<Calendar> { @Override public Calendar convert(String value, Class<? extends Calendar> type) { if (isNullOrEmpty(value)) { return null; } try { Date date = getDateFormat().parse(value); Calendar calendar = Calendar.getInstance(locale); calendar.setTime(date); return calendar; } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected CalendarConverter(); @Inject CalendarConverter(Locale locale); } | CalendarConverter implements Converter<Calendar> { @Override public Calendar convert(String value, Class<? extends Calendar> type) { if (isNullOrEmpty(value)) { return null; } try { Date date = getDateFormat().parse(value); Calendar calendar = Calendar.getInstance(locale); calendar.setTime(date); return calendar; } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected CalendarConverter(); @Inject CalendarConverter(Locale locale); @Override Calendar convert(String value, Class<? extends Calendar> type); } | CalendarConverter implements Converter<Calendar> { @Override public Calendar convert(String value, Class<? extends Calendar> type) { if (isNullOrEmpty(value)) { return null; } try { Date date = getDateFormat().parse(value); Calendar calendar = Calendar.getInstance(locale); calendar.setTime(date); return calendar; } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected CalendarConverter(); @Inject CalendarConverter(Locale locale); @Override Calendar convert(String value, Class<? extends Calendar> type); static final String INVALID_MESSAGE_KEY; } |
@Test public void shouldBeAbleToConvertNumbers() { assertThat(converter.convert("7", byte.class), is(equalTo((byte) 7))); } | @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return (byte) 0; } try { return Byte.parseByte(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } | PrimitiveByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return (byte) 0; } try { return Byte.parseByte(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } } | PrimitiveByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return (byte) 0; } try { return Byte.parseByte(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } } | PrimitiveByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return (byte) 0; } try { return Byte.parseByte(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Byte convert(String value, Class<? extends Byte> type); } | PrimitiveByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return (byte) 0; } try { return Byte.parseByte(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Byte convert(String value, Class<? extends Byte> type); static final String INVALID_MESSAGE_KEY; } |
@Test public void shouldComplainAboutInvalidNumber() { exception.expect(hasConversionException("--- is not a valid number.")); converter.convert("---", byte.class); } | @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return (byte) 0; } try { return Byte.parseByte(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } | PrimitiveByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return (byte) 0; } try { return Byte.parseByte(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } } | PrimitiveByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return (byte) 0; } try { return Byte.parseByte(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } } | PrimitiveByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return (byte) 0; } try { return Byte.parseByte(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Byte convert(String value, Class<? extends Byte> type); } | PrimitiveByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return (byte) 0; } try { return Byte.parseByte(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Byte convert(String value, Class<? extends Byte> type); static final String INVALID_MESSAGE_KEY; } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.